[Commits] Rev 3516: Casandra SE: in file:///data0/psergey/dev2/5.5-cassandra-r02/

Sergey Petrunya psergey at askmonty.org
Thu Sep 20 17:32:37 EEST 2012


At file:///data0/psergey/dev2/5.5-cassandra-r02/

------------------------------------------------------------
revno: 3516
revision-id: psergey at askmonty.org-20120920143237-og4d9qh8uiojasmi
parent: psergey at askmonty.org-20120920102236-1wb6p3dfkui79yux
committer: Sergey Petrunya <psergey at askmonty.org>
branch nick: 5.5-cassandra-r02
timestamp: Thu 2012-09-20 18:32:37 +0400
message:
  Casandra SE:
  - Introduce asynchronous operations
  - parallel INSERT operation.
=== modified file 'storage/cassandra/CMakeLists.txt'
--- a/storage/cassandra/CMakeLists.txt	2012-08-17 17:13:20 +0000
+++ b/storage/cassandra/CMakeLists.txt	2012-09-20 14:32:37 +0000
@@ -4,19 +4,20 @@
      ha_cassandra.h 
      cassandra_se.h
      cassandra_se.cc
-     gen-cpp/Cassandra.cpp
-     gen-cpp/cassandra_types.h 
-     gen-cpp/cassandra_types.cpp
-     gen-cpp/cassandra_constants.h 
-     gen-cpp/cassandra_constants.cpp
-     gen-cpp/Cassandra.h)
+     gen-cpp-async/Cassandra.cpp
+     gen-cpp-async/cassandra_types.h 
+     gen-cpp-async/cassandra_types.cpp
+     gen-cpp-async/cassandra_constants.h 
+     gen-cpp-async/cassandra_constants.cpp
+     gen-cpp-async/Cassandra.h)
 
 #INCLUDE_DIRECTORIES(BEFORE ${Boost_INCLUDE_DIRS})
-INCLUDE_DIRECTORIES(AFTER /home/psergey/cassandra/thrift/include/thrift/) 
+INCLUDE_DIRECTORIES(AFTER /home/psergey/cassandra/thrift-async/include/thrift/)
+INCLUDE_DIRECTORIES(AFTER /home/psergey/cassandra/thrift-async/include)
 # 
 STRING(REPLACE "-fno-exceptions" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 STRING(REPLACE "-fno-implicit-templates" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 #LINK_DIRECTORIES(/home/psergey/cassandra/thrift/lib)
 
-MYSQL_ADD_PLUGIN(cassandra ${cassandra_sources} STORAGE_ENGINE LINK_LIBRARIES thrift)
+MYSQL_ADD_PLUGIN(cassandra ${cassandra_sources} STORAGE_ENGINE LINK_LIBRARIES thrift thriftasio boost_system)
 # was: STORAGE_ENGINE MANDATORY 

=== modified file 'storage/cassandra/cassandra_se.cc'
--- a/storage/cassandra/cassandra_se.cc	2012-09-16 08:22:21 +0000
+++ b/storage/cassandra/cassandra_se.cc	2012-09-20 14:32:37 +0000
@@ -6,13 +6,18 @@
 #include <stdio.h>
 #include <stdarg.h>
 
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+
+#include <async/TAsioAsync.h>
+
 #include "Thrift.h"
 #include "transport/TSocket.h"
 #include "transport/TTransport.h"
 #include "transport/TBufferTransports.h"
 #include "protocol/TProtocol.h"
 #include "protocol/TBinaryProtocol.h"
-#include "gen-cpp/Cassandra.h"
+#include "gen-cpp-async/Cassandra.h"
 // cassandra includes end
 
 #include "cassandra_se.h"
@@ -37,12 +42,26 @@
 */
 class Cassandra_se_impl: public Cassandra_se_interface
 {
-  CassandraClient *cass; /* Connection to cassandra */
+  /* Parameters */ 
+  std::vector<std::string> hosts_list;
   ConsistencyLevel::type cur_consistency_level;
-
   std::string column_family;
   std::string keyspace;
   
+  /* Connection handlers */
+  boost::asio::io_service io_service;
+  boost::shared_ptr<protocol::TProtocolFactory> protocolFactory;
+
+  //boost::shared_ptr<async::TAsioClient> client;
+  std::vector<boost::shared_ptr<async::TAsioClient> > clients;
+
+  std::vector<boost::shared_ptr<CassandraAsyncClient> > async_clients;
+  
+  // DELETE THIS: v
+  CassandraClient *cass; /* Connection to cassandra */
+
+
+  
   /* DDL data */
   KsDef ks_def; /* KeySpace we're using (TODO: put this in table->share) */
   CfDef cf_def; /* Column family we're using (TODO: put in table->share)*/
@@ -56,8 +75,13 @@
   typedef std::map<std::string, std::vector<Mutation> > ColumnFamilyToMutation;
   typedef std::map<std::string,  ColumnFamilyToMutation> KeyToCfMutationMap;
    
-  KeyToCfMutationMap batch_mutation; /* Prepare operation here */
-  int64_t insert_timestamp;
+  std::vector<KeyToCfMutationMap> batch_mutations; /* Prepare operation here */
+  KeyToCfMutationMap *batch_mutation; /* Prepare operation here */
+  uint batch_mutation_idx;
+  
+  int64_t insert_timestamp; /* rows will be inserted with this timestamp */
+  
+  /* Current row mutation being filled */
   std::vector<Mutation>* insert_list;
    
   /* Resultset we're reading */
@@ -69,10 +93,11 @@
   SlicePredicate slice_pred;
   bool get_slices_returned_less;
 public:
-  Cassandra_se_impl() : cass(NULL) {}
-  virtual ~Cassandra_se_impl(){ delete cass; }
+  Cassandra_se_impl() /* : cass(NULL) */ {}
+  virtual ~Cassandra_se_impl(){ /*delete cass; */ }
   
   /* Connection and DDL checks */
+  bool make_hosts_list(const char *hosts);
   bool connect(const char *host, int port, const char *keyspace);
   void set_column_family(const char *cfname) { column_family.assign(cfname); }
 
@@ -85,7 +110,7 @@
   void clear_insert_buffer();
   void start_row_insert(const char *key, int key_len);
   void add_insert_column(const char *name, const char *value, int value_len);
-  bool do_insert();
+  bool do_insert(bool flush);
 
   /* Reads, point lookups */
   bool get_slice(char *key, size_t key_len, bool *found);
@@ -123,6 +148,22 @@
 private:
   /* Non-inherited utility functions: */
   int64_t get_i64_timestamp();
+
+  void on_connected2(boost::shared_ptr< CassandraAsyncClient> client);
+  void on_set_keyspace();
+  void on_set_keyspace_fail();
+  void on_describe_keyspace(org::apache::cassandra::KsDef ks_def_arg);
+  void on_batch_mutate_done();
+
+  uint connected;
+  uint keyspace_set;
+  bool describe_keyspace_done;
+  uint batch_mutations_to_do;
+
+  bool remove_op_done;
+  void on_remove_done() { remove_op_done= true; }
+
+  bool error_happened;
 };
 
 
@@ -135,15 +176,115 @@
 }
 
 
+void Cassandra_se_impl::on_connected2(boost::shared_ptr<CassandraAsyncClient> client)
+{
+  async_clients.push_back(client);
+  connected++;
+  fprintf(stderr, "=Connected!\n");
+}
+
+
+void Cassandra_se_impl::on_set_keyspace()
+{
+  keyspace_set++;
+  fprintf(stderr, "=Keyspace set!\n");
+}
+
+void Cassandra_se_impl::on_set_keyspace_fail()
+{
+  keyspace_set++;
+  error_happened= true;
+}
+
+bool Cassandra_se_impl::make_hosts_list(const char *hosts)
+{
+  const char* p= hosts;
+  const char* name_start=p;
+  hosts_list.clear();
+  while (1)
+  {
+    if (*p==0 || *p==',')
+    {
+      // [name_start; p) is the name
+      size_t len= p - name_start;
+      if (len==0)
+        return true;
+      hosts_list.push_back(std::string(name_start, len));
+      name_start= p + 1;
+      if (*p == 0)
+        break;
+    }
+    p++;
+  }
+  if (hosts_list.size() > 0)
+    return false; /* OK */
+  else
+    return true; /* Empty list: error */
+}
+
+
 bool Cassandra_se_impl::connect(const char *host, int port, const char *keyspace_arg)
 {
   bool res= true;
   
+  if (make_hosts_list(host))
+    return true;
+
   keyspace.assign(keyspace_arg);
-  
+
+  try {
+    protocolFactory= boost::shared_ptr<protocol::TProtocolFactory>(new protocol::TBinaryProtocolFactory());
+    clients.resize(hosts_list.size());
+
+    for (uint i= 0; i < hosts_list.size(); i++)
+    {
+      clients[i]= boost::shared_ptr<async::TAsioClient>(
+                             new async::TAsioClient(io_service, 
+                              protocolFactory, protocolFactory));
+
+      boost::function<void (boost::shared_ptr<CassandraAsyncClient> c )> call_me;
+      call_me= boost::bind(&Cassandra_se_impl::on_connected2, this, _1);
+
+      clients[i]->connect(hosts_list[i], port, call_me);
+    }
+    connected= 0;
+
+    //io_service.run();
+    while (connected !=hosts_list.size())
+    {
+      size_t cnt= io_service.run_one();
+      fprintf(stderr, "processed %d events\n", (int)cnt);
+    }
+
+    keyspace_set= 0;
+    error_happened=false;
+    for (uint i= 0; i < hosts_list.size(); i++)
+    {
+      boost::function< void () > call_on_connect;
+      call_on_connect= boost::bind(&Cassandra_se_impl::on_set_keyspace, this);
+      async_clients[i]->set_keyspace(keyspace_arg).
+        setCallback(boost::bind(&Cassandra_se_impl::on_set_keyspace, this)).
+        setErrback(boost::bind(&Cassandra_se_impl::on_set_keyspace_fail, this));
+    }
+
+    while (keyspace_set != hosts_list.size())
+    {
+      size_t cnt= io_service.run_one();
+      fprintf(stderr, "processed %d events\n", (int)cnt);
+    }
+    if (error_happened)
+      res= true;
+    else
+      res= false;
+
+  }catch (...) {
+    print_error("Unknown exception");
+  }
+
+#if 1  
   try {
     boost::shared_ptr<TTransport> socket = 
-      boost::shared_ptr<TSocket>(new TSocket(host, port));
+      boost::shared_ptr<TSocket>(new TSocket(hosts_list[0], port));
     boost::shared_ptr<TTransport> tr = 
       boost::shared_ptr<TFramedTransport>(new TFramedTransport (socket));
     boost::shared_ptr<TProtocol> p = 
@@ -165,6 +306,7 @@
   }catch (...) {
     print_error("Unknown exception");
   }
+#endif  
 
   cur_consistency_level= ConsistencyLevel::ONE;
 
@@ -174,21 +316,30 @@
 }
 
 
+void Cassandra_se_impl::on_describe_keyspace(org::apache::cassandra::KsDef ks_def_arg)
+{
+  fprintf(stderr, "=describe_keyspace_done");
+  ks_def= ks_def_arg;
+  describe_keyspace_done= true;
+}
+
+
 bool Cassandra_se_impl::setup_ddl_checks()
 {
+  describe_keyspace_done= false;
+  async_clients[0]->describe_keyspace(keyspace).
+                    setCallback(boost::bind(&Cassandra_se_impl::on_describe_keyspace,
+                    this, _1));
+
+  while (!describe_keyspace_done)
+  {
+    size_t cnt= io_service.run_one();
+    fprintf(stderr, "processed %d events\n", (int)cnt);
+  }
+
+#if 0  
   try {
     cass->describe_keyspace(ks_def, keyspace);
-
-    std::vector<CfDef>::iterator it;
-    for (it= ks_def.cf_defs.begin(); it < ks_def.cf_defs.end(); it++)
-    {
-      cf_def= *it;
-      if (!cf_def.name.compare(column_family))
-        return false;
-    }
-
-    print_error("describe_keyspace() didn't return our column family");
-
   } catch (InvalidRequestException ire) {
     print_error("%s [%s]", ire.what(), ire.why.c_str());
   } catch (NotFoundException nfe) {
@@ -198,6 +349,17 @@
   } catch (...) {
     print_error("Unknown exception");
   }
+#endif
+
+  std::vector<CfDef>::iterator it;
+  for (it= ks_def.cf_defs.begin(); it < ks_def.cf_defs.end(); it++)
+  {
+    cf_def= *it;
+    if (!cf_def.name.compare(column_family))
+      return false;
+  }
+
+  print_error("describe_keyspace() didn't return our column family");
 
   return true;
 }
@@ -259,7 +421,12 @@
 
 void Cassandra_se_impl::clear_insert_buffer()
 {
-  batch_mutation.clear();
+  batch_mutations.resize(hosts_list.size());
+  for (uint i=0; i < hosts_list.size(); i++)
+    batch_mutations[i]= KeyToCfMutationMap();
+
+  batch_mutation_idx= 0;
+  batch_mutation= &batch_mutations[batch_mutation_idx];
 }
 
 
@@ -267,8 +434,8 @@
 {
   std::string key_to_insert;
   key_to_insert.assign(key, key_len);
-  batch_mutation[key_to_insert]= ColumnFamilyToMutation();
-  ColumnFamilyToMutation& cf_mut= batch_mutation[key_to_insert];
+  (*batch_mutation)[key_to_insert]= ColumnFamilyToMutation();
+  ColumnFamilyToMutation& cf_mut= (*batch_mutation)[key_to_insert];
 
   cf_mut[column_family]= std::vector<Mutation>();
   insert_list= &cf_mut[column_family];
@@ -294,18 +461,55 @@
 }
 
 
-bool Cassandra_se_impl::do_insert()
+void Cassandra_se_impl::on_batch_mutate_done()
+{
+  batch_mutations_to_do--;
+}
+
+
+bool Cassandra_se_impl::do_insert(bool flush)
 {
   bool res= true;
+  size_t size= hosts_list.size();
+
+  if (!flush)
+  {
+    /* Switch to constructing another mutation object */
+    if (batch_mutation_idx != size - 1)
+    {
+      batch_mutation= &batch_mutations[++batch_mutation_idx];
+      return false;
+    }
+  }
+
+  for (uint i= 0; i < size; i++)
+  {
+    /*
+      zero-size mutations are allowed by Cassandra's batch_mutate but lets not 
+      do them (we may attempt to do it if there is a bulk insert that stores
+      exactly @@cassandra_insert_batch_size*n elements.
+    */
+    if (batch_mutations[i].empty())
+      continue;
+ 
+    batch_mutations_to_do++;
+    async_clients[i]->batch_mutate(batch_mutations[i], cur_consistency_level).
+      setCallback(boost::bind(&Cassandra_se_impl::on_batch_mutate_done, this));
+
+    cassandra_counters.row_inserts+= batch_mutations[i].size();
+    cassandra_counters.row_insert_batches++;
+  }
   
-  /*
-    zero-size mutations are allowed by Cassandra's batch_mutate but lets not 
-    do them (we may attempt to do it if there is a bulk insert that stores
-    exactly @@cassandra_insert_batch_size*n elements.
-  */
-  if (batch_mutation.empty())
-    return false;
-
+  while (batch_mutations_to_do != 0)
+  {
+    io_service.run_one();
+    //fprintf(stderr, "bm processed %d events\n", (int)cnt);
+  }
+  res= false;
+
+  clear_insert_buffer();
+
+#if 0
   try {
     
     cass->batch_mutate(batch_mutation, cur_consistency_level);
@@ -327,7 +531,7 @@
   } catch (...) {
     print_error("Unknown exception");
   }
-
+#endif
   return res;
 }
 
@@ -587,6 +791,18 @@
   ColumnPath column_path;
   column_path.column_family= column_family;
 
+  remove_op_done= false;
+  async_clients[0]->remove(rowkey, column_path, get_i64_timestamp(), cur_consistency_level).
+      setCallback(boost::bind(&Cassandra_se_impl::on_remove_done, this));
+  
+  
+  while (!remove_op_done)
+  {
+    io_service.run_one();
+  }
+  res= false;
+
+#if 0
   try {
     
     cass->remove(rowkey, column_path, get_i64_timestamp(), cur_consistency_level);
@@ -603,7 +819,7 @@
   } catch (...) {
     print_error("Unknown exception");
   }
-
+#endif
   return res;
 }
 

=== modified file 'storage/cassandra/cassandra_se.h'
--- a/storage/cassandra/cassandra_se.h	2012-09-16 08:22:21 +0000
+++ b/storage/cassandra/cassandra_se.h	2012-09-20 14:32:37 +0000
@@ -32,7 +32,7 @@
   virtual void start_row_insert(const char *key, int key_len)=0;
   virtual void add_insert_column(const char *name, const char *value, 
                                  int value_len)=0;
-  virtual bool do_insert()=0;
+  virtual bool do_insert(bool flush)=0;
 
   /* Reads */
   virtual bool get_slice(char *key, size_t key_len, bool *found)=0 ;

=== added directory 'storage/cassandra/gen-cpp-async'
=== added file 'storage/cassandra/gen-cpp-async/Cassandra.cpp'
--- a/storage/cassandra/gen-cpp-async/Cassandra.cpp	1970-01-01 00:00:00 +0000
+++ b/storage/cassandra/gen-cpp-async/Cassandra.cpp	2012-09-20 14:32:37 +0000
@@ -0,0 +1,19068 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0-dev)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "Cassandra.h"
+
+namespace org { namespace apache { namespace cassandra {
+
+uint32_t Cassandra_login_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_auth_request = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->auth_request.read(iprot);
+          isset_auth_request = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_auth_request)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_login_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_login_args");
+
+  xfer += oprot->writeFieldBegin("auth_request", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->auth_request.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_login_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_login_pargs");
+
+  xfer += oprot->writeFieldBegin("auth_request", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->auth_request)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_login_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->authnx.read(iprot);
+          this->__isset.authnx = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->authzx.read(iprot);
+          this->__isset.authzx = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_login_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_login_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.authnx) {
+    xfer += oprot->writeFieldBegin("authnx", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->authnx.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.authzx) {
+    xfer += oprot->writeFieldBegin("authzx", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->authzx.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_login_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->authnx.read(iprot);
+          this->__isset.authnx = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->authzx.read(iprot);
+          this->__isset.authzx = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_set_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keyspace = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->keyspace);
+          isset_keyspace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keyspace)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_set_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_set_keyspace_args");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->keyspace);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_set_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_set_keyspace_pargs");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->keyspace)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_set_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_set_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_set_keyspace_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_set_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_column_path = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_path.read(iprot);
+          isset_column_path = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast149;
+          xfer += iprot->readI32(ecast149);
+          this->consistency_level = (ConsistencyLevel::type)ecast149;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_path)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_get_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_args");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_path.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_pargs");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->key)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_path)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->nfe.read(iprot);
+          this->__isset.nfe = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_get_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.nfe) {
+    xfer += oprot->writeFieldBegin("nfe", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->nfe.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 4);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->nfe.read(iprot);
+          this->__isset.nfe = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_slice_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_column_parent = false;
+  bool isset_predicate = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->predicate.read(iprot);
+          isset_predicate = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast150;
+          xfer += iprot->readI32(ecast150);
+          this->consistency_level = (ConsistencyLevel::type)ecast150;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_predicate)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_get_slice_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_slice_args");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->predicate.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_slice_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_slice_pargs");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->key)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->predicate)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_slice_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size151;
+            ::apache::thrift::protocol::TType _etype154;
+            xfer += iprot->readListBegin(_etype154, _size151);
+            this->success.resize(_size151);
+            uint32_t _i155;
+            for (_i155 = 0; _i155 < _size151; ++_i155)
+            {
+              xfer += this->success[_i155].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_slice_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_get_slice_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<ColumnOrSuperColumn> ::const_iterator _iter156;
+      for (_iter156 = this->success.begin(); _iter156 != this->success.end(); ++_iter156)
+      {
+        xfer += (*_iter156).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_slice_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size157;
+            ::apache::thrift::protocol::TType _etype160;
+            xfer += iprot->readListBegin(_etype160, _size157);
+            (*(this->success)).resize(_size157);
+            uint32_t _i161;
+            for (_i161 = 0; _i161 < _size157; ++_i161)
+            {
+              xfer += (*(this->success))[_i161].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_count_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_column_parent = false;
+  bool isset_predicate = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->predicate.read(iprot);
+          isset_predicate = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast162;
+          xfer += iprot->readI32(ecast162);
+          this->consistency_level = (ConsistencyLevel::type)ecast162;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_predicate)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_get_count_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_count_args");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->predicate.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_count_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_count_pargs");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->key)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->predicate)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_count_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_count_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_get_count_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
+    xfer += oprot->writeI32(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_count_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_slice_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keys = false;
+  bool isset_column_parent = false;
+  bool isset_predicate = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->keys.clear();
+            uint32_t _size163;
+            ::apache::thrift::protocol::TType _etype166;
+            xfer += iprot->readListBegin(_etype166, _size163);
+            this->keys.resize(_size163);
+            uint32_t _i167;
+            for (_i167 = 0; _i167 < _size163; ++_i167)
+            {
+              xfer += iprot->readBinary(this->keys[_i167]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_keys = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->predicate.read(iprot);
+          isset_predicate = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast168;
+          xfer += iprot->readI32(ecast168);
+          this->consistency_level = (ConsistencyLevel::type)ecast168;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keys)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_predicate)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_slice_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_multiget_slice_args");
+
+  xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->keys.size()));
+    std::vector<std::string> ::const_iterator _iter169;
+    for (_iter169 = this->keys.begin(); _iter169 != this->keys.end(); ++_iter169)
+    {
+      xfer += oprot->writeBinary((*_iter169));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->predicate.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_slice_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_multiget_slice_pargs");
+
+  xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->keys)).size()));
+    std::vector<std::string> ::const_iterator _iter170;
+    for (_iter170 = (*(this->keys)).begin(); _iter170 != (*(this->keys)).end(); ++_iter170)
+    {
+      xfer += oprot->writeBinary((*_iter170));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->predicate)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_slice_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->success.clear();
+            uint32_t _size171;
+            ::apache::thrift::protocol::TType _ktype172;
+            ::apache::thrift::protocol::TType _vtype173;
+            xfer += iprot->readMapBegin(_ktype172, _vtype173, _size171);
+            uint32_t _i175;
+            for (_i175 = 0; _i175 < _size171; ++_i175)
+            {
+              std::string _key176;
+              xfer += iprot->readBinary(_key176);
+              std::vector<ColumnOrSuperColumn> & _val177 = this->success[_key176];
+              {
+                _val177.clear();
+                uint32_t _size178;
+                ::apache::thrift::protocol::TType _etype181;
+                xfer += iprot->readListBegin(_etype181, _size178);
+                _val177.resize(_size178);
+                uint32_t _i182;
+                for (_i182 = 0; _i182 < _size178; ++_i182)
+                {
+                  xfer += _val177[_i182].read(iprot);
+                }
+                xfer += iprot->readListEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_slice_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_multiget_slice_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string, std::vector<ColumnOrSuperColumn> > ::const_iterator _iter183;
+      for (_iter183 = this->success.begin(); _iter183 != this->success.end(); ++_iter183)
+      {
+        xfer += oprot->writeBinary(_iter183->first);
+        {
+          xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter183->second.size()));
+          std::vector<ColumnOrSuperColumn> ::const_iterator _iter184;
+          for (_iter184 = _iter183->second.begin(); _iter184 != _iter183->second.end(); ++_iter184)
+          {
+            xfer += (*_iter184).write(oprot);
+          }
+          xfer += oprot->writeListEnd();
+        }
+      }
+      xfer += oprot->writeMapEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_slice_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size185;
+            ::apache::thrift::protocol::TType _ktype186;
+            ::apache::thrift::protocol::TType _vtype187;
+            xfer += iprot->readMapBegin(_ktype186, _vtype187, _size185);
+            uint32_t _i189;
+            for (_i189 = 0; _i189 < _size185; ++_i189)
+            {
+              std::string _key190;
+              xfer += iprot->readBinary(_key190);
+              std::vector<ColumnOrSuperColumn> & _val191 = (*(this->success))[_key190];
+              {
+                _val191.clear();
+                uint32_t _size192;
+                ::apache::thrift::protocol::TType _etype195;
+                xfer += iprot->readListBegin(_etype195, _size192);
+                _val191.resize(_size192);
+                uint32_t _i196;
+                for (_i196 = 0; _i196 < _size192; ++_i196)
+                {
+                  xfer += _val191[_i196].read(iprot);
+                }
+                xfer += iprot->readListEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_count_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keys = false;
+  bool isset_column_parent = false;
+  bool isset_predicate = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->keys.clear();
+            uint32_t _size197;
+            ::apache::thrift::protocol::TType _etype200;
+            xfer += iprot->readListBegin(_etype200, _size197);
+            this->keys.resize(_size197);
+            uint32_t _i201;
+            for (_i201 = 0; _i201 < _size197; ++_i201)
+            {
+              xfer += iprot->readBinary(this->keys[_i201]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_keys = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->predicate.read(iprot);
+          isset_predicate = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast202;
+          xfer += iprot->readI32(ecast202);
+          this->consistency_level = (ConsistencyLevel::type)ecast202;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keys)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_predicate)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_count_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_multiget_count_args");
+
+  xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->keys.size()));
+    std::vector<std::string> ::const_iterator _iter203;
+    for (_iter203 = this->keys.begin(); _iter203 != this->keys.end(); ++_iter203)
+    {
+      xfer += oprot->writeBinary((*_iter203));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->predicate.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_count_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_multiget_count_pargs");
+
+  xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->keys)).size()));
+    std::vector<std::string> ::const_iterator _iter204;
+    for (_iter204 = (*(this->keys)).begin(); _iter204 != (*(this->keys)).end(); ++_iter204)
+    {
+      xfer += oprot->writeBinary((*_iter204));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->predicate)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_count_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->success.clear();
+            uint32_t _size205;
+            ::apache::thrift::protocol::TType _ktype206;
+            ::apache::thrift::protocol::TType _vtype207;
+            xfer += iprot->readMapBegin(_ktype206, _vtype207, _size205);
+            uint32_t _i209;
+            for (_i209 = 0; _i209 < _size205; ++_i209)
+            {
+              std::string _key210;
+              xfer += iprot->readBinary(_key210);
+              int32_t& _val211 = this->success[_key210];
+              xfer += iprot->readI32(_val211);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_count_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_multiget_count_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string, int32_t> ::const_iterator _iter212;
+      for (_iter212 = this->success.begin(); _iter212 != this->success.end(); ++_iter212)
+      {
+        xfer += oprot->writeBinary(_iter212->first);
+        xfer += oprot->writeI32(_iter212->second);
+      }
+      xfer += oprot->writeMapEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_multiget_count_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size213;
+            ::apache::thrift::protocol::TType _ktype214;
+            ::apache::thrift::protocol::TType _vtype215;
+            xfer += iprot->readMapBegin(_ktype214, _vtype215, _size213);
+            uint32_t _i217;
+            for (_i217 = 0; _i217 < _size213; ++_i217)
+            {
+              std::string _key218;
+              xfer += iprot->readBinary(_key218);
+              int32_t& _val219 = (*(this->success))[_key218];
+              xfer += iprot->readI32(_val219);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_range_slices_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_column_parent = false;
+  bool isset_predicate = false;
+  bool isset_range = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->predicate.read(iprot);
+          isset_predicate = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->range.read(iprot);
+          isset_range = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast220;
+          xfer += iprot->readI32(ecast220);
+          this->consistency_level = (ConsistencyLevel::type)ecast220;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_predicate)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_range)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_get_range_slices_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_range_slices_args");
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->predicate.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("range", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->range.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_range_slices_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_range_slices_pargs");
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->predicate)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("range", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->range)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_range_slices_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size221;
+            ::apache::thrift::protocol::TType _etype224;
+            xfer += iprot->readListBegin(_etype224, _size221);
+            this->success.resize(_size221);
+            uint32_t _i225;
+            for (_i225 = 0; _i225 < _size221; ++_i225)
+            {
+              xfer += this->success[_i225].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_range_slices_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_get_range_slices_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<KeySlice> ::const_iterator _iter226;
+      for (_iter226 = this->success.begin(); _iter226 != this->success.end(); ++_iter226)
+      {
+        xfer += (*_iter226).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_range_slices_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size227;
+            ::apache::thrift::protocol::TType _etype230;
+            xfer += iprot->readListBegin(_etype230, _size227);
+            (*(this->success)).resize(_size227);
+            uint32_t _i231;
+            for (_i231 = 0; _i231 < _size227; ++_i231)
+            {
+              xfer += (*(this->success))[_i231].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_paged_slice_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_column_family = false;
+  bool isset_range = false;
+  bool isset_start_column = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->column_family);
+          isset_column_family = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->range.read(iprot);
+          isset_range = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->start_column);
+          isset_start_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast232;
+          xfer += iprot->readI32(ecast232);
+          this->consistency_level = (ConsistencyLevel::type)ecast232;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_column_family)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_range)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_start_column)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_get_paged_slice_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_paged_slice_args");
+
+  xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->column_family);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("range", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->range.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("start_column", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeBinary(this->start_column);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_paged_slice_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_paged_slice_pargs");
+
+  xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->column_family)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("range", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->range)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("start_column", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeBinary((*(this->start_column)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_paged_slice_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size233;
+            ::apache::thrift::protocol::TType _etype236;
+            xfer += iprot->readListBegin(_etype236, _size233);
+            this->success.resize(_size233);
+            uint32_t _i237;
+            for (_i237 = 0; _i237 < _size233; ++_i237)
+            {
+              xfer += this->success[_i237].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_paged_slice_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_get_paged_slice_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<KeySlice> ::const_iterator _iter238;
+      for (_iter238 = this->success.begin(); _iter238 != this->success.end(); ++_iter238)
+      {
+        xfer += (*_iter238).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_paged_slice_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size239;
+            ::apache::thrift::protocol::TType _etype242;
+            xfer += iprot->readListBegin(_etype242, _size239);
+            (*(this->success)).resize(_size239);
+            uint32_t _i243;
+            for (_i243 = 0; _i243 < _size239; ++_i243)
+            {
+              xfer += (*(this->success))[_i243].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_indexed_slices_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_column_parent = false;
+  bool isset_index_clause = false;
+  bool isset_column_predicate = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->index_clause.read(iprot);
+          isset_index_clause = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_predicate.read(iprot);
+          isset_column_predicate = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast244;
+          xfer += iprot->readI32(ecast244);
+          this->consistency_level = (ConsistencyLevel::type)ecast244;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_index_clause)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_predicate)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_get_indexed_slices_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_indexed_slices_args");
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("index_clause", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->index_clause.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->column_predicate.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_indexed_slices_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_get_indexed_slices_pargs");
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("index_clause", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->index_clause)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->column_predicate)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_indexed_slices_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size245;
+            ::apache::thrift::protocol::TType _etype248;
+            xfer += iprot->readListBegin(_etype248, _size245);
+            this->success.resize(_size245);
+            uint32_t _i249;
+            for (_i249 = 0; _i249 < _size245; ++_i249)
+            {
+              xfer += this->success[_i249].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_get_indexed_slices_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_get_indexed_slices_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<KeySlice> ::const_iterator _iter250;
+      for (_iter250 = this->success.begin(); _iter250 != this->success.end(); ++_iter250)
+      {
+        xfer += (*_iter250).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_get_indexed_slices_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size251;
+            ::apache::thrift::protocol::TType _etype254;
+            xfer += iprot->readListBegin(_etype254, _size251);
+            (*(this->success)).resize(_size251);
+            uint32_t _i255;
+            for (_i255 = 0; _i255 < _size251; ++_i255)
+            {
+              xfer += (*(this->success))[_i255].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_insert_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_column_parent = false;
+  bool isset_column = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column.read(iprot);
+          isset_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast256;
+          xfer += iprot->readI32(ecast256);
+          this->consistency_level = (ConsistencyLevel::type)ecast256;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_insert_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_insert_args");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->column.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_insert_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_insert_pargs");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->key)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->column)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_insert_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_insert_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_insert_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_insert_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_add_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_column_parent = false;
+  bool isset_column = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_parent.read(iprot);
+          isset_column_parent = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column.read(iprot);
+          isset_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast257;
+          xfer += iprot->readI32(ecast257);
+          this->consistency_level = (ConsistencyLevel::type)ecast257;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_parent)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_add_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_add_args");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_parent.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->column.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_add_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_add_pargs");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->key)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_parent)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->column)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_add_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_add_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_add_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_add_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_remove_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_column_path = false;
+  bool isset_timestamp = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_path.read(iprot);
+          isset_column_path = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->timestamp);
+          isset_timestamp = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast258;
+          xfer += iprot->readI32(ecast258);
+          this->consistency_level = (ConsistencyLevel::type)ecast258;
+          this->__isset.consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_column_path)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_timestamp)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_remove_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_remove_args");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->column_path.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
+  xfer += oprot->writeI64(this->timestamp);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_remove_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_remove_pargs");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->key)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->column_path)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
+  xfer += oprot->writeI64((*(this->timestamp)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_remove_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_remove_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_remove_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_remove_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_remove_counter_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_path = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->path.read(iprot);
+          isset_path = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast259;
+          xfer += iprot->readI32(ecast259);
+          this->consistency_level = (ConsistencyLevel::type)ecast259;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_path)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_remove_counter_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_remove_counter_args");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("path", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->path.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_remove_counter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_remove_counter_pargs");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->key)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("path", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->path)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_remove_counter_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_remove_counter_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_remove_counter_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_remove_counter_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_batch_mutate_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_mutation_map = false;
+  bool isset_consistency_level = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->mutation_map.clear();
+            uint32_t _size260;
+            ::apache::thrift::protocol::TType _ktype261;
+            ::apache::thrift::protocol::TType _vtype262;
+            xfer += iprot->readMapBegin(_ktype261, _vtype262, _size260);
+            uint32_t _i264;
+            for (_i264 = 0; _i264 < _size260; ++_i264)
+            {
+              std::string _key265;
+              xfer += iprot->readBinary(_key265);
+              std::map<std::string, std::vector<Mutation> > & _val266 = this->mutation_map[_key265];
+              {
+                _val266.clear();
+                uint32_t _size267;
+                ::apache::thrift::protocol::TType _ktype268;
+                ::apache::thrift::protocol::TType _vtype269;
+                xfer += iprot->readMapBegin(_ktype268, _vtype269, _size267);
+                uint32_t _i271;
+                for (_i271 = 0; _i271 < _size267; ++_i271)
+                {
+                  std::string _key272;
+                  xfer += iprot->readString(_key272);
+                  std::vector<Mutation> & _val273 = _val266[_key272];
+                  {
+                    _val273.clear();
+                    uint32_t _size274;
+                    ::apache::thrift::protocol::TType _etype277;
+                    xfer += iprot->readListBegin(_etype277, _size274);
+                    _val273.resize(_size274);
+                    uint32_t _i278;
+                    for (_i278 = 0; _i278 < _size274; ++_i278)
+                    {
+                      xfer += _val273[_i278].read(iprot);
+                    }
+                    xfer += iprot->readListEnd();
+                  }
+                }
+                xfer += iprot->readMapEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_mutation_map = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast279;
+          xfer += iprot->readI32(ecast279);
+          this->consistency_level = (ConsistencyLevel::type)ecast279;
+          isset_consistency_level = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_mutation_map)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_consistency_level)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_batch_mutate_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_batch_mutate_args");
+
+  xfer += oprot->writeFieldBegin("mutation_map", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_MAP, static_cast<uint32_t>(this->mutation_map.size()));
+    std::map<std::string, std::map<std::string, std::vector<Mutation> > > ::const_iterator _iter280;
+    for (_iter280 = this->mutation_map.begin(); _iter280 != this->mutation_map.end(); ++_iter280)
+    {
+      xfer += oprot->writeBinary(_iter280->first);
+      {
+        xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(_iter280->second.size()));
+        std::map<std::string, std::vector<Mutation> > ::const_iterator _iter281;
+        for (_iter281 = _iter280->second.begin(); _iter281 != _iter280->second.end(); ++_iter281)
+        {
+          xfer += oprot->writeString(_iter281->first);
+          {
+            xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter281->second.size()));
+            std::vector<Mutation> ::const_iterator _iter282;
+            for (_iter282 = _iter281->second.begin(); _iter282 != _iter281->second.end(); ++_iter282)
+            {
+              xfer += (*_iter282).write(oprot);
+            }
+            xfer += oprot->writeListEnd();
+          }
+        }
+        xfer += oprot->writeMapEnd();
+      }
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->consistency_level);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_batch_mutate_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_batch_mutate_pargs");
+
+  xfer += oprot->writeFieldBegin("mutation_map", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_MAP, static_cast<uint32_t>((*(this->mutation_map)).size()));
+    std::map<std::string, std::map<std::string, std::vector<Mutation> > > ::const_iterator _iter283;
+    for (_iter283 = (*(this->mutation_map)).begin(); _iter283 != (*(this->mutation_map)).end(); ++_iter283)
+    {
+      xfer += oprot->writeBinary(_iter283->first);
+      {
+        xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(_iter283->second.size()));
+        std::map<std::string, std::vector<Mutation> > ::const_iterator _iter284;
+        for (_iter284 = _iter283->second.begin(); _iter284 != _iter283->second.end(); ++_iter284)
+        {
+          xfer += oprot->writeString(_iter284->first);
+          {
+            xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter284->second.size()));
+            std::vector<Mutation> ::const_iterator _iter285;
+            for (_iter285 = _iter284->second.begin(); _iter285 != _iter284->second.end(); ++_iter285)
+            {
+              xfer += (*_iter285).write(oprot);
+            }
+            xfer += oprot->writeListEnd();
+          }
+        }
+        xfer += oprot->writeMapEnd();
+      }
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_batch_mutate_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_batch_mutate_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_batch_mutate_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_batch_mutate_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_truncate_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_cfname = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->cfname);
+          isset_cfname = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_cfname)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_truncate_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_truncate_args");
+
+  xfer += oprot->writeFieldBegin("cfname", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->cfname);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_truncate_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_truncate_pargs");
+
+  xfer += oprot->writeFieldBegin("cfname", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->cfname)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_truncate_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_truncate_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_truncate_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_truncate_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_schema_versions_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_schema_versions_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_schema_versions_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_schema_versions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_schema_versions_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_schema_versions_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->success.clear();
+            uint32_t _size286;
+            ::apache::thrift::protocol::TType _ktype287;
+            ::apache::thrift::protocol::TType _vtype288;
+            xfer += iprot->readMapBegin(_ktype287, _vtype288, _size286);
+            uint32_t _i290;
+            for (_i290 = 0; _i290 < _size286; ++_i290)
+            {
+              std::string _key291;
+              xfer += iprot->readString(_key291);
+              std::vector<std::string> & _val292 = this->success[_key291];
+              {
+                _val292.clear();
+                uint32_t _size293;
+                ::apache::thrift::protocol::TType _etype296;
+                xfer += iprot->readListBegin(_etype296, _size293);
+                _val292.resize(_size293);
+                uint32_t _i297;
+                for (_i297 = 0; _i297 < _size293; ++_i297)
+                {
+                  xfer += iprot->readString(_val292[_i297]);
+                }
+                xfer += iprot->readListEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_schema_versions_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_schema_versions_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string, std::vector<std::string> > ::const_iterator _iter298;
+      for (_iter298 = this->success.begin(); _iter298 != this->success.end(); ++_iter298)
+      {
+        xfer += oprot->writeString(_iter298->first);
+        {
+          xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter298->second.size()));
+          std::vector<std::string> ::const_iterator _iter299;
+          for (_iter299 = _iter298->second.begin(); _iter299 != _iter298->second.end(); ++_iter299)
+          {
+            xfer += oprot->writeString((*_iter299));
+          }
+          xfer += oprot->writeListEnd();
+        }
+      }
+      xfer += oprot->writeMapEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_schema_versions_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size300;
+            ::apache::thrift::protocol::TType _ktype301;
+            ::apache::thrift::protocol::TType _vtype302;
+            xfer += iprot->readMapBegin(_ktype301, _vtype302, _size300);
+            uint32_t _i304;
+            for (_i304 = 0; _i304 < _size300; ++_i304)
+            {
+              std::string _key305;
+              xfer += iprot->readString(_key305);
+              std::vector<std::string> & _val306 = (*(this->success))[_key305];
+              {
+                _val306.clear();
+                uint32_t _size307;
+                ::apache::thrift::protocol::TType _etype310;
+                xfer += iprot->readListBegin(_etype310, _size307);
+                _val306.resize(_size307);
+                uint32_t _i311;
+                for (_i311 = 0; _i311 < _size307; ++_i311)
+                {
+                  xfer += iprot->readString(_val306[_i311]);
+                }
+                xfer += iprot->readListEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspaces_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspaces_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_keyspaces_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspaces_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_keyspaces_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspaces_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size312;
+            ::apache::thrift::protocol::TType _etype315;
+            xfer += iprot->readListBegin(_etype315, _size312);
+            this->success.resize(_size312);
+            uint32_t _i316;
+            for (_i316 = 0; _i316 < _size312; ++_i316)
+            {
+              xfer += this->success[_i316].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspaces_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_keyspaces_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<KsDef> ::const_iterator _iter317;
+      for (_iter317 = this->success.begin(); _iter317 != this->success.end(); ++_iter317)
+      {
+        xfer += (*_iter317).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspaces_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size318;
+            ::apache::thrift::protocol::TType _etype321;
+            xfer += iprot->readListBegin(_etype321, _size318);
+            (*(this->success)).resize(_size318);
+            uint32_t _i322;
+            for (_i322 = 0; _i322 < _size318; ++_i322)
+            {
+              xfer += (*(this->success))[_i322].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_cluster_name_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_cluster_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_cluster_name_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_cluster_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_cluster_name_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_cluster_name_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_cluster_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_cluster_name_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_cluster_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_version_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_version_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_version_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_version_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_version_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_version_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_version_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_version_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_version_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_ring_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keyspace = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->keyspace);
+          isset_keyspace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keyspace)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_describe_ring_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_ring_args");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->keyspace);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_ring_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_ring_pargs");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->keyspace)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_ring_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size323;
+            ::apache::thrift::protocol::TType _etype326;
+            xfer += iprot->readListBegin(_etype326, _size323);
+            this->success.resize(_size323);
+            uint32_t _i327;
+            for (_i327 = 0; _i327 < _size323; ++_i327)
+            {
+              xfer += this->success[_i327].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_ring_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_ring_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<TokenRange> ::const_iterator _iter328;
+      for (_iter328 = this->success.begin(); _iter328 != this->success.end(); ++_iter328)
+      {
+        xfer += (*_iter328).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_ring_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size329;
+            ::apache::thrift::protocol::TType _etype332;
+            xfer += iprot->readListBegin(_etype332, _size329);
+            (*(this->success)).resize(_size329);
+            uint32_t _i333;
+            for (_i333 = 0; _i333 < _size329; ++_i333)
+            {
+              xfer += (*(this->success))[_i333].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_token_map_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_token_map_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_token_map_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_token_map_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_token_map_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_token_map_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->success.clear();
+            uint32_t _size334;
+            ::apache::thrift::protocol::TType _ktype335;
+            ::apache::thrift::protocol::TType _vtype336;
+            xfer += iprot->readMapBegin(_ktype335, _vtype336, _size334);
+            uint32_t _i338;
+            for (_i338 = 0; _i338 < _size334; ++_i338)
+            {
+              std::string _key339;
+              xfer += iprot->readString(_key339);
+              std::string& _val340 = this->success[_key339];
+              xfer += iprot->readString(_val340);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_token_map_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_token_map_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string, std::string> ::const_iterator _iter341;
+      for (_iter341 = this->success.begin(); _iter341 != this->success.end(); ++_iter341)
+      {
+        xfer += oprot->writeString(_iter341->first);
+        xfer += oprot->writeString(_iter341->second);
+      }
+      xfer += oprot->writeMapEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_token_map_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size342;
+            ::apache::thrift::protocol::TType _ktype343;
+            ::apache::thrift::protocol::TType _vtype344;
+            xfer += iprot->readMapBegin(_ktype343, _vtype344, _size342);
+            uint32_t _i346;
+            for (_i346 = 0; _i346 < _size342; ++_i346)
+            {
+              std::string _key347;
+              xfer += iprot->readString(_key347);
+              std::string& _val348 = (*(this->success))[_key347];
+              xfer += iprot->readString(_val348);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_partitioner_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_partitioner_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_partitioner_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_partitioner_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_partitioner_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_partitioner_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_partitioner_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_partitioner_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_partitioner_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_snitch_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_snitch_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_snitch_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_snitch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_snitch_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_snitch_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_snitch_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_snitch_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_snitch_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keyspace = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->keyspace);
+          isset_keyspace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keyspace)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_keyspace_args");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->keyspace);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_keyspace_pargs");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->keyspace)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->nfe.read(iprot);
+          this->__isset.nfe = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_keyspace_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.nfe) {
+    xfer += oprot->writeFieldBegin("nfe", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->nfe.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->nfe.read(iprot);
+          this->__isset.nfe = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_splits_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_cfName = false;
+  bool isset_start_token = false;
+  bool isset_end_token = false;
+  bool isset_keys_per_split = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->cfName);
+          isset_cfName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->start_token);
+          isset_start_token = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->end_token);
+          isset_end_token = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->keys_per_split);
+          isset_keys_per_split = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_cfName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_start_token)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_end_token)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_keys_per_split)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_describe_splits_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_splits_args");
+
+  xfer += oprot->writeFieldBegin("cfName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->cfName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->start_token);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->end_token);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("keys_per_split", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32(this->keys_per_split);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_splits_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_describe_splits_pargs");
+
+  xfer += oprot->writeFieldBegin("cfName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->cfName)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->start_token)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString((*(this->end_token)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("keys_per_split", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((*(this->keys_per_split)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_splits_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size349;
+            ::apache::thrift::protocol::TType _etype352;
+            xfer += iprot->readListBegin(_etype352, _size349);
+            this->success.resize(_size349);
+            uint32_t _i353;
+            for (_i353 = 0; _i353 < _size349; ++_i353)
+            {
+              xfer += iprot->readString(this->success[_i353]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_describe_splits_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_describe_splits_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
+      std::vector<std::string> ::const_iterator _iter354;
+      for (_iter354 = this->success.begin(); _iter354 != this->success.end(); ++_iter354)
+      {
+        xfer += oprot->writeString((*_iter354));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_describe_splits_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size355;
+            ::apache::thrift::protocol::TType _etype358;
+            xfer += iprot->readListBegin(_etype358, _size355);
+            (*(this->success)).resize(_size355);
+            uint32_t _i359;
+            for (_i359 = 0; _i359 < _size355; ++_i359)
+            {
+              xfer += iprot->readString((*(this->success))[_i359]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_column_family_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_cf_def = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->cf_def.read(iprot);
+          isset_cf_def = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_cf_def)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_column_family_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_add_column_family_args");
+
+  xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->cf_def.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_column_family_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_add_column_family_pargs");
+
+  xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->cf_def)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_column_family_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_column_family_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_system_add_column_family_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_column_family_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_column_family_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_column_family = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->column_family);
+          isset_column_family = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_column_family)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_column_family_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_drop_column_family_args");
+
+  xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->column_family);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_column_family_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_drop_column_family_pargs");
+
+  xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->column_family)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_column_family_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_column_family_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_system_drop_column_family_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_column_family_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_ks_def = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ks_def.read(iprot);
+          isset_ks_def = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_ks_def)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_add_keyspace_args");
+
+  xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->ks_def.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_add_keyspace_pargs");
+
+  xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->ks_def)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_system_add_keyspace_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_add_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keyspace = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->keyspace);
+          isset_keyspace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keyspace)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_drop_keyspace_args");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->keyspace);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_drop_keyspace_pargs");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->keyspace)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_system_drop_keyspace_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_drop_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_ks_def = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ks_def.read(iprot);
+          isset_ks_def = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_ks_def)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_update_keyspace_args");
+
+  xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->ks_def.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_update_keyspace_pargs");
+
+  xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->ks_def)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_system_update_keyspace_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_column_family_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_cf_def = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->cf_def.read(iprot);
+          isset_cf_def = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_cf_def)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_column_family_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_update_column_family_args");
+
+  xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->cf_def.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_column_family_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_system_update_column_family_pargs");
+
+  xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->cf_def)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_column_family_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_column_family_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_system_update_column_family_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_system_update_column_family_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_execute_cql_query_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_query = false;
+  bool isset_compression = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->query);
+          isset_query = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast360;
+          xfer += iprot->readI32(ecast360);
+          this->compression = (Compression::type)ecast360;
+          isset_compression = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_query)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_compression)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_execute_cql_query_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_execute_cql_query_args");
+
+  xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->query);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->compression);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_execute_cql_query_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_execute_cql_query_pargs");
+
+  xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->query)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)(*(this->compression)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_execute_cql_query_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_execute_cql_query_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_execute_cql_query_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 4);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_execute_cql_query_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_prepare_cql_query_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_query = false;
+  bool isset_compression = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->query);
+          isset_query = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast361;
+          xfer += iprot->readI32(ecast361);
+          this->compression = (Compression::type)ecast361;
+          isset_compression = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_query)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_compression)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_prepare_cql_query_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_prepare_cql_query_args");
+
+  xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->query);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->compression);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_prepare_cql_query_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_prepare_cql_query_pargs");
+
+  xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary((*(this->query)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)(*(this->compression)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_prepare_cql_query_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_prepare_cql_query_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_prepare_cql_query_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_prepare_cql_query_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_execute_prepared_cql_query_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_itemId = false;
+  bool isset_values = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->itemId);
+          isset_itemId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->values.clear();
+            uint32_t _size362;
+            ::apache::thrift::protocol::TType _etype365;
+            xfer += iprot->readListBegin(_etype365, _size362);
+            this->values.resize(_size362);
+            uint32_t _i366;
+            for (_i366 = 0; _i366 < _size362; ++_i366)
+            {
+              xfer += iprot->readBinary(this->values[_i366]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_values = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_itemId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_values)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_execute_prepared_cql_query_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_execute_prepared_cql_query_args");
+
+  xfer += oprot->writeFieldBegin("itemId", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32(this->itemId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
+    std::vector<std::string> ::const_iterator _iter367;
+    for (_iter367 = this->values.begin(); _iter367 != this->values.end(); ++_iter367)
+    {
+      xfer += oprot->writeBinary((*_iter367));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_execute_prepared_cql_query_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_execute_prepared_cql_query_pargs");
+
+  xfer += oprot->writeFieldBegin("itemId", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((*(this->itemId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->values)).size()));
+    std::vector<std::string> ::const_iterator _iter368;
+    for (_iter368 = (*(this->values)).begin(); _iter368 != (*(this->values)).end(); ++_iter368)
+    {
+      xfer += oprot->writeBinary((*_iter368));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_execute_prepared_cql_query_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_execute_prepared_cql_query_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_execute_prepared_cql_query_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ue) {
+    xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ue.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.te) {
+    xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->te.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.sde) {
+    xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 4);
+    xfer += this->sde.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_execute_prepared_cql_query_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ue.read(iprot);
+          this->__isset.ue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->te.read(iprot);
+          this->__isset.te = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sde.read(iprot);
+          this->__isset.sde = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_set_cql_version_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_version = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->version);
+          isset_version = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_version)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Cassandra_set_cql_version_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_set_cql_version_args");
+
+  xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->version);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_set_cql_version_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Cassandra_set_cql_version_pargs");
+
+  xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->version)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_set_cql_version_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->failure.read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Cassandra_set_cql_version_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Cassandra_set_cql_version_result");
+
+  if (this->__isset.failure) {
+    xfer += oprot->writeFieldBegin("failure", ::apache::thrift::protocol::T_STRUCT, -1337);
+    xfer += this->failure.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Cassandra_set_cql_version_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case -1337:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->failure)).read(iprot);
+          this->__isset.failure = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+void CassandraClient::login(const AuthenticationRequest& auth_request)
+{
+  send_login(auth_request);
+  recv_login();
+}
+
+void CassandraClient::send_login(const AuthenticationRequest& auth_request)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("login", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_login_pargs args;
+  args.auth_request = &auth_request;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_login()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("login") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_login_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.authnx) {
+    throw result.authnx;
+  }
+  if (result.__isset.authzx) {
+    throw result.authzx;
+  }
+  return;
+}
+
+void CassandraClient::set_keyspace(const std::string& keyspace)
+{
+  send_set_keyspace(keyspace);
+  recv_set_keyspace();
+}
+
+void CassandraClient::send_set_keyspace(const std::string& keyspace)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("set_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_set_keyspace_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_set_keyspace()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("set_keyspace") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_set_keyspace_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  return;
+}
+
+void CassandraClient::get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level)
+{
+  send_get(key, column_path, consistency_level);
+  recv_get(_return);
+}
+
+void CassandraClient::send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_pargs args;
+  args.key = &key;
+  args.column_path = &column_path;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_get(ColumnOrSuperColumn& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("get") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_get_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get failed: unknown result");
+}
+
+void CassandraClient::get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_get_slice(key, column_parent, predicate, consistency_level);
+  recv_get_slice(_return);
+}
+
+void CassandraClient::send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_slice", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_slice_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_get_slice(std::vector<ColumnOrSuperColumn> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("get_slice") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_get_slice_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_slice failed: unknown result");
+}
+
+int32_t CassandraClient::get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_get_count(key, column_parent, predicate, consistency_level);
+  return recv_get_count();
+}
+
+void CassandraClient::send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_count", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_count_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+int32_t CassandraClient::recv_get_count()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("get_count") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  int32_t _return;
+  Cassandra_get_count_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    return _return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_count failed: unknown result");
+}
+
+void CassandraClient::multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_multiget_slice(keys, column_parent, predicate, consistency_level);
+  recv_multiget_slice(_return);
+}
+
+void CassandraClient::send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("multiget_slice", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_multiget_slice_pargs args;
+  args.keys = &keys;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("multiget_slice") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_multiget_slice_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "multiget_slice failed: unknown result");
+}
+
+void CassandraClient::multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_multiget_count(keys, column_parent, predicate, consistency_level);
+  recv_multiget_count(_return);
+}
+
+void CassandraClient::send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("multiget_count", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_multiget_count_pargs args;
+  args.keys = &keys;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_multiget_count(std::map<std::string, int32_t> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("multiget_count") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_multiget_count_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "multiget_count failed: unknown result");
+}
+
+void CassandraClient::get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level)
+{
+  send_get_range_slices(column_parent, predicate, range, consistency_level);
+  recv_get_range_slices(_return);
+}
+
+void CassandraClient::send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_range_slices", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_range_slices_pargs args;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.range = &range;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_get_range_slices(std::vector<KeySlice> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("get_range_slices") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_get_range_slices_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_range_slices failed: unknown result");
+}
+
+void CassandraClient::get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level)
+{
+  send_get_paged_slice(column_family, range, start_column, consistency_level);
+  recv_get_paged_slice(_return);
+}
+
+void CassandraClient::send_get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_paged_slice", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_paged_slice_pargs args;
+  args.column_family = &column_family;
+  args.range = &range;
+  args.start_column = &start_column;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_get_paged_slice(std::vector<KeySlice> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("get_paged_slice") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_get_paged_slice_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_paged_slice failed: unknown result");
+}
+
+void CassandraClient::get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_get_indexed_slices(column_parent, index_clause, column_predicate, consistency_level);
+  recv_get_indexed_slices(_return);
+}
+
+void CassandraClient::send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_indexed_slices", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_indexed_slices_pargs 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_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_get_indexed_slices(std::vector<KeySlice> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("get_indexed_slices") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_get_indexed_slices_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_indexed_slices failed: unknown result");
+}
+
+void CassandraClient::insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level)
+{
+  send_insert(key, column_parent, column, consistency_level);
+  recv_insert();
+}
+
+void CassandraClient::send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("insert", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_insert_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.column = &column;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_insert()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("insert") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_insert_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  return;
+}
+
+void CassandraClient::add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level)
+{
+  send_add(key, column_parent, column, consistency_level);
+  recv_add();
+}
+
+void CassandraClient::send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("add", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_add_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.column = &column;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_add()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("add") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_add_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  return;
+}
+
+void CassandraClient::remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level)
+{
+  send_remove(key, column_path, timestamp, consistency_level);
+  recv_remove();
+}
+
+void CassandraClient::send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("remove", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_remove_pargs args;
+  args.key = &key;
+  args.column_path = &column_path;
+  args.timestamp = &timestamp;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_remove()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("remove") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_remove_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  return;
+}
+
+void CassandraClient::remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level)
+{
+  send_remove_counter(key, path, consistency_level);
+  recv_remove_counter();
+}
+
+void CassandraClient::send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("remove_counter", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_remove_counter_pargs args;
+  args.key = &key;
+  args.path = &path;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_remove_counter()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("remove_counter") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_remove_counter_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  return;
+}
+
+void CassandraClient::batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level)
+{
+  send_batch_mutate(mutation_map, consistency_level);
+  recv_batch_mutate();
+}
+
+void CassandraClient::send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("batch_mutate", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_batch_mutate_pargs args;
+  args.mutation_map = &mutation_map;
+  args.consistency_level = &consistency_level;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_batch_mutate()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("batch_mutate") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_batch_mutate_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  return;
+}
+
+void CassandraClient::truncate(const std::string& cfname)
+{
+  send_truncate(cfname);
+  recv_truncate();
+}
+
+void CassandraClient::send_truncate(const std::string& cfname)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("truncate", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_truncate_pargs args;
+  args.cfname = &cfname;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_truncate()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("truncate") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_truncate_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  return;
+}
+
+void CassandraClient::describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return)
+{
+  send_describe_schema_versions();
+  recv_describe_schema_versions(_return);
+}
+
+void CassandraClient::send_describe_schema_versions()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_schema_versions", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_schema_versions_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_schema_versions") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_schema_versions_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_schema_versions failed: unknown result");
+}
+
+void CassandraClient::describe_keyspaces(std::vector<KsDef> & _return)
+{
+  send_describe_keyspaces();
+  recv_describe_keyspaces(_return);
+}
+
+void CassandraClient::send_describe_keyspaces()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_keyspaces", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_keyspaces_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_keyspaces(std::vector<KsDef> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_keyspaces") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_keyspaces_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_keyspaces failed: unknown result");
+}
+
+void CassandraClient::describe_cluster_name(std::string& _return)
+{
+  send_describe_cluster_name();
+  recv_describe_cluster_name(_return);
+}
+
+void CassandraClient::send_describe_cluster_name()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_cluster_name", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_cluster_name_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_cluster_name(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_cluster_name") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_cluster_name_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_cluster_name failed: unknown result");
+}
+
+void CassandraClient::describe_version(std::string& _return)
+{
+  send_describe_version();
+  recv_describe_version(_return);
+}
+
+void CassandraClient::send_describe_version()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_version", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_version_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_version(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_version") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_version_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_version failed: unknown result");
+}
+
+void CassandraClient::describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace)
+{
+  send_describe_ring(keyspace);
+  recv_describe_ring(_return);
+}
+
+void CassandraClient::send_describe_ring(const std::string& keyspace)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_ring", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_ring_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_ring(std::vector<TokenRange> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_ring") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_ring_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_ring failed: unknown result");
+}
+
+void CassandraClient::describe_token_map(std::map<std::string, std::string> & _return)
+{
+  send_describe_token_map();
+  recv_describe_token_map(_return);
+}
+
+void CassandraClient::send_describe_token_map()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_token_map", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_token_map_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_token_map(std::map<std::string, std::string> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_token_map") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_token_map_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_token_map failed: unknown result");
+}
+
+void CassandraClient::describe_partitioner(std::string& _return)
+{
+  send_describe_partitioner();
+  recv_describe_partitioner(_return);
+}
+
+void CassandraClient::send_describe_partitioner()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_partitioner", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_partitioner_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_partitioner(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_partitioner") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_partitioner_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_partitioner failed: unknown result");
+}
+
+void CassandraClient::describe_snitch(std::string& _return)
+{
+  send_describe_snitch();
+  recv_describe_snitch(_return);
+}
+
+void CassandraClient::send_describe_snitch()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_snitch", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_snitch_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_snitch(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_snitch") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_snitch_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_snitch failed: unknown result");
+}
+
+void CassandraClient::describe_keyspace(KsDef& _return, const std::string& keyspace)
+{
+  send_describe_keyspace(keyspace);
+  recv_describe_keyspace(_return);
+}
+
+void CassandraClient::send_describe_keyspace(const std::string& keyspace)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_keyspace_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_keyspace(KsDef& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_keyspace") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_keyspace_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.nfe) {
+    throw result.nfe;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_keyspace failed: unknown result");
+}
+
+void CassandraClient::describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split)
+{
+  send_describe_splits(cfName, start_token, end_token, keys_per_split);
+  recv_describe_splits(_return);
+}
+
+void CassandraClient::send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("describe_splits", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_splits_pargs 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_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_describe_splits(std::vector<std::string> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("describe_splits") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_describe_splits_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_splits failed: unknown result");
+}
+
+void CassandraClient::system_add_column_family(std::string& _return, const CfDef& cf_def)
+{
+  send_system_add_column_family(cf_def);
+  recv_system_add_column_family(_return);
+}
+
+void CassandraClient::send_system_add_column_family(const CfDef& cf_def)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("system_add_column_family", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_add_column_family_pargs args;
+  args.cf_def = &cf_def;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_system_add_column_family(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("system_add_column_family") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_system_add_column_family_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_add_column_family failed: unknown result");
+}
+
+void CassandraClient::system_drop_column_family(std::string& _return, const std::string& column_family)
+{
+  send_system_drop_column_family(column_family);
+  recv_system_drop_column_family(_return);
+}
+
+void CassandraClient::send_system_drop_column_family(const std::string& column_family)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("system_drop_column_family", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_drop_column_family_pargs args;
+  args.column_family = &column_family;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_system_drop_column_family(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("system_drop_column_family") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_system_drop_column_family_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_drop_column_family failed: unknown result");
+}
+
+void CassandraClient::system_add_keyspace(std::string& _return, const KsDef& ks_def)
+{
+  send_system_add_keyspace(ks_def);
+  recv_system_add_keyspace(_return);
+}
+
+void CassandraClient::send_system_add_keyspace(const KsDef& ks_def)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("system_add_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_add_keyspace_pargs args;
+  args.ks_def = &ks_def;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_system_add_keyspace(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("system_add_keyspace") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_system_add_keyspace_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_add_keyspace failed: unknown result");
+}
+
+void CassandraClient::system_drop_keyspace(std::string& _return, const std::string& keyspace)
+{
+  send_system_drop_keyspace(keyspace);
+  recv_system_drop_keyspace(_return);
+}
+
+void CassandraClient::send_system_drop_keyspace(const std::string& keyspace)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("system_drop_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_drop_keyspace_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_system_drop_keyspace(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("system_drop_keyspace") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_system_drop_keyspace_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_drop_keyspace failed: unknown result");
+}
+
+void CassandraClient::system_update_keyspace(std::string& _return, const KsDef& ks_def)
+{
+  send_system_update_keyspace(ks_def);
+  recv_system_update_keyspace(_return);
+}
+
+void CassandraClient::send_system_update_keyspace(const KsDef& ks_def)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("system_update_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_update_keyspace_pargs args;
+  args.ks_def = &ks_def;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_system_update_keyspace(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("system_update_keyspace") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_system_update_keyspace_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_update_keyspace failed: unknown result");
+}
+
+void CassandraClient::system_update_column_family(std::string& _return, const CfDef& cf_def)
+{
+  send_system_update_column_family(cf_def);
+  recv_system_update_column_family(_return);
+}
+
+void CassandraClient::send_system_update_column_family(const CfDef& cf_def)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("system_update_column_family", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_update_column_family_pargs args;
+  args.cf_def = &cf_def;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_system_update_column_family(std::string& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("system_update_column_family") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_system_update_column_family_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_update_column_family failed: unknown result");
+}
+
+void CassandraClient::execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression)
+{
+  send_execute_cql_query(query, compression);
+  recv_execute_cql_query(_return);
+}
+
+void CassandraClient::send_execute_cql_query(const std::string& query, const Compression::type compression)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("execute_cql_query", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_execute_cql_query_pargs args;
+  args.query = &query;
+  args.compression = &compression;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_execute_cql_query(CqlResult& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("execute_cql_query") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_execute_cql_query_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "execute_cql_query failed: unknown result");
+}
+
+void CassandraClient::prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression)
+{
+  send_prepare_cql_query(query, compression);
+  recv_prepare_cql_query(_return);
+}
+
+void CassandraClient::send_prepare_cql_query(const std::string& query, const Compression::type compression)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("prepare_cql_query", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_prepare_cql_query_pargs args;
+  args.query = &query;
+  args.compression = &compression;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_prepare_cql_query(CqlPreparedResult& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("prepare_cql_query") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_prepare_cql_query_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "prepare_cql_query failed: unknown result");
+}
+
+void CassandraClient::execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values)
+{
+  send_execute_prepared_cql_query(itemId, values);
+  recv_execute_prepared_cql_query(_return);
+}
+
+void CassandraClient::send_execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("execute_prepared_cql_query", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_execute_prepared_cql_query_pargs args;
+  args.itemId = &itemId;
+  args.values = &values;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_execute_prepared_cql_query(CqlResult& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("execute_prepared_cql_query") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_execute_prepared_cql_query_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ue) {
+    throw result.ue;
+  }
+  if (result.__isset.te) {
+    throw result.te;
+  }
+  if (result.__isset.sde) {
+    throw result.sde;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "execute_prepared_cql_query failed: unknown result");
+}
+
+void CassandraClient::set_cql_version(const std::string& version)
+{
+  send_set_cql_version(version);
+  recv_set_cql_version();
+}
+
+void CassandraClient::send_set_cql_version(const std::string& version)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("set_cql_version", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_set_cql_version_pargs args;
+  args.version = &version;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CassandraClient::recv_set_cql_version()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("set_cql_version") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Cassandra_set_cql_version_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  return;
+}
+
+bool CassandraProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
+  ProcessMap::iterator pfn;
+  pfn = processMap_.find(fname);
+  if (pfn == processMap_.end()) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
+    oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return true;
+  }
+  (this->*(pfn->second))(seqid, iprot, oprot, callContext);
+  return true;
+}
+
+void CassandraProcessor::process_login(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.login", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.login");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.login");
+  }
+
+  Cassandra_login_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.login", bytes);
+  }
+
+  Cassandra_login_result result;
+  try {
+    iface_->login(args.auth_request);
+  } catch (AuthenticationException &authnx) {
+    result.authnx = authnx;
+    result.__isset.authnx = true;
+  } catch (AuthorizationException &authzx) {
+    result.authzx = authzx;
+    result.__isset.authzx = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.login");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("login", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.login");
+  }
+
+  oprot->writeMessageBegin("login", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.login", bytes);
+  }
+}
+
+void CassandraProcessor::process_set_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.set_keyspace", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.set_keyspace");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.set_keyspace");
+  }
+
+  Cassandra_set_keyspace_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.set_keyspace", bytes);
+  }
+
+  Cassandra_set_keyspace_result result;
+  try {
+    iface_->set_keyspace(args.keyspace);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.set_keyspace");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("set_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.set_keyspace");
+  }
+
+  oprot->writeMessageBegin("set_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.set_keyspace", bytes);
+  }
+}
+
+void CassandraProcessor::process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.get", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.get");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.get");
+  }
+
+  Cassandra_get_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.get", bytes);
+  }
+
+  Cassandra_get_result result;
+  try {
+    iface_->get(result.success, args.key, args.column_path, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (NotFoundException &nfe) {
+    result.nfe = nfe;
+    result.__isset.nfe = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.get");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.get");
+  }
+
+  oprot->writeMessageBegin("get", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.get", bytes);
+  }
+}
+
+void CassandraProcessor::process_get_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.get_slice", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.get_slice");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.get_slice");
+  }
+
+  Cassandra_get_slice_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.get_slice", bytes);
+  }
+
+  Cassandra_get_slice_result result;
+  try {
+    iface_->get_slice(result.success, args.key, args.column_parent, args.predicate, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.get_slice");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_slice", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.get_slice");
+  }
+
+  oprot->writeMessageBegin("get_slice", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.get_slice", bytes);
+  }
+}
+
+void CassandraProcessor::process_get_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.get_count", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.get_count");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.get_count");
+  }
+
+  Cassandra_get_count_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.get_count", bytes);
+  }
+
+  Cassandra_get_count_result result;
+  try {
+    result.success = iface_->get_count(args.key, args.column_parent, args.predicate, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.get_count");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_count", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.get_count");
+  }
+
+  oprot->writeMessageBegin("get_count", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.get_count", bytes);
+  }
+}
+
+void CassandraProcessor::process_multiget_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.multiget_slice", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.multiget_slice");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.multiget_slice");
+  }
+
+  Cassandra_multiget_slice_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.multiget_slice", bytes);
+  }
+
+  Cassandra_multiget_slice_result result;
+  try {
+    iface_->multiget_slice(result.success, args.keys, args.column_parent, args.predicate, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.multiget_slice");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("multiget_slice", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.multiget_slice");
+  }
+
+  oprot->writeMessageBegin("multiget_slice", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.multiget_slice", bytes);
+  }
+}
+
+void CassandraProcessor::process_multiget_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.multiget_count", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.multiget_count");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.multiget_count");
+  }
+
+  Cassandra_multiget_count_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.multiget_count", bytes);
+  }
+
+  Cassandra_multiget_count_result result;
+  try {
+    iface_->multiget_count(result.success, args.keys, args.column_parent, args.predicate, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.multiget_count");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("multiget_count", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.multiget_count");
+  }
+
+  oprot->writeMessageBegin("multiget_count", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.multiget_count", bytes);
+  }
+}
+
+void CassandraProcessor::process_get_range_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.get_range_slices", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.get_range_slices");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.get_range_slices");
+  }
+
+  Cassandra_get_range_slices_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.get_range_slices", bytes);
+  }
+
+  Cassandra_get_range_slices_result result;
+  try {
+    iface_->get_range_slices(result.success, args.column_parent, args.predicate, args.range, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.get_range_slices");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_range_slices", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.get_range_slices");
+  }
+
+  oprot->writeMessageBegin("get_range_slices", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.get_range_slices", bytes);
+  }
+}
+
+void CassandraProcessor::process_get_paged_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.get_paged_slice", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.get_paged_slice");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.get_paged_slice");
+  }
+
+  Cassandra_get_paged_slice_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.get_paged_slice", bytes);
+  }
+
+  Cassandra_get_paged_slice_result result;
+  try {
+    iface_->get_paged_slice(result.success, args.column_family, args.range, args.start_column, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.get_paged_slice");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_paged_slice", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.get_paged_slice");
+  }
+
+  oprot->writeMessageBegin("get_paged_slice", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.get_paged_slice", bytes);
+  }
+}
+
+void CassandraProcessor::process_get_indexed_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.get_indexed_slices", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.get_indexed_slices");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.get_indexed_slices");
+  }
+
+  Cassandra_get_indexed_slices_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.get_indexed_slices", bytes);
+  }
+
+  Cassandra_get_indexed_slices_result result;
+  try {
+    iface_->get_indexed_slices(result.success, args.column_parent, args.index_clause, args.column_predicate, args.consistency_level);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.get_indexed_slices");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_indexed_slices", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.get_indexed_slices");
+  }
+
+  oprot->writeMessageBegin("get_indexed_slices", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.get_indexed_slices", bytes);
+  }
+}
+
+void CassandraProcessor::process_insert(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.insert", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.insert");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.insert");
+  }
+
+  Cassandra_insert_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.insert", bytes);
+  }
+
+  Cassandra_insert_result result;
+  try {
+    iface_->insert(args.key, args.column_parent, args.column, args.consistency_level);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.insert");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("insert", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.insert");
+  }
+
+  oprot->writeMessageBegin("insert", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.insert", bytes);
+  }
+}
+
+void CassandraProcessor::process_add(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.add", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.add");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.add");
+  }
+
+  Cassandra_add_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.add", bytes);
+  }
+
+  Cassandra_add_result result;
+  try {
+    iface_->add(args.key, args.column_parent, args.column, args.consistency_level);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.add");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("add", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.add");
+  }
+
+  oprot->writeMessageBegin("add", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.add", bytes);
+  }
+}
+
+void CassandraProcessor::process_remove(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.remove", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.remove");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.remove");
+  }
+
+  Cassandra_remove_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.remove", bytes);
+  }
+
+  Cassandra_remove_result result;
+  try {
+    iface_->remove(args.key, args.column_path, args.timestamp, args.consistency_level);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.remove");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("remove", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.remove");
+  }
+
+  oprot->writeMessageBegin("remove", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.remove", bytes);
+  }
+}
+
+void CassandraProcessor::process_remove_counter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.remove_counter", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.remove_counter");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.remove_counter");
+  }
+
+  Cassandra_remove_counter_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.remove_counter", bytes);
+  }
+
+  Cassandra_remove_counter_result result;
+  try {
+    iface_->remove_counter(args.key, args.path, args.consistency_level);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.remove_counter");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("remove_counter", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.remove_counter");
+  }
+
+  oprot->writeMessageBegin("remove_counter", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.remove_counter", bytes);
+  }
+}
+
+void CassandraProcessor::process_batch_mutate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.batch_mutate", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.batch_mutate");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.batch_mutate");
+  }
+
+  Cassandra_batch_mutate_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.batch_mutate", bytes);
+  }
+
+  Cassandra_batch_mutate_result result;
+  try {
+    iface_->batch_mutate(args.mutation_map, args.consistency_level);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.batch_mutate");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("batch_mutate", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.batch_mutate");
+  }
+
+  oprot->writeMessageBegin("batch_mutate", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.batch_mutate", bytes);
+  }
+}
+
+void CassandraProcessor::process_truncate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.truncate", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.truncate");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.truncate");
+  }
+
+  Cassandra_truncate_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.truncate", bytes);
+  }
+
+  Cassandra_truncate_result result;
+  try {
+    iface_->truncate(args.cfname);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.truncate");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("truncate", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.truncate");
+  }
+
+  oprot->writeMessageBegin("truncate", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.truncate", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_schema_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_schema_versions", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_schema_versions");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_schema_versions");
+  }
+
+  Cassandra_describe_schema_versions_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_schema_versions", bytes);
+  }
+
+  Cassandra_describe_schema_versions_result result;
+  try {
+    iface_->describe_schema_versions(result.success);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_schema_versions");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_schema_versions", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_schema_versions");
+  }
+
+  oprot->writeMessageBegin("describe_schema_versions", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_schema_versions", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_keyspaces(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_keyspaces", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_keyspaces");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_keyspaces");
+  }
+
+  Cassandra_describe_keyspaces_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_keyspaces", bytes);
+  }
+
+  Cassandra_describe_keyspaces_result result;
+  try {
+    iface_->describe_keyspaces(result.success);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_keyspaces");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_keyspaces", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_keyspaces");
+  }
+
+  oprot->writeMessageBegin("describe_keyspaces", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_keyspaces", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_cluster_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_cluster_name", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_cluster_name");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_cluster_name");
+  }
+
+  Cassandra_describe_cluster_name_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_cluster_name", bytes);
+  }
+
+  Cassandra_describe_cluster_name_result result;
+  try {
+    iface_->describe_cluster_name(result.success);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_cluster_name");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_cluster_name", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_cluster_name");
+  }
+
+  oprot->writeMessageBegin("describe_cluster_name", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_cluster_name", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_version", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_version");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_version");
+  }
+
+  Cassandra_describe_version_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_version", bytes);
+  }
+
+  Cassandra_describe_version_result result;
+  try {
+    iface_->describe_version(result.success);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_version");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_version", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_version");
+  }
+
+  oprot->writeMessageBegin("describe_version", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_version", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_ring(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_ring", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_ring");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_ring");
+  }
+
+  Cassandra_describe_ring_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_ring", bytes);
+  }
+
+  Cassandra_describe_ring_result result;
+  try {
+    iface_->describe_ring(result.success, args.keyspace);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_ring");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_ring", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_ring");
+  }
+
+  oprot->writeMessageBegin("describe_ring", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_ring", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_token_map(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_token_map", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_token_map");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_token_map");
+  }
+
+  Cassandra_describe_token_map_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_token_map", bytes);
+  }
+
+  Cassandra_describe_token_map_result result;
+  try {
+    iface_->describe_token_map(result.success);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_token_map");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_token_map", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_token_map");
+  }
+
+  oprot->writeMessageBegin("describe_token_map", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_token_map", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_partitioner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_partitioner", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_partitioner");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_partitioner");
+  }
+
+  Cassandra_describe_partitioner_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_partitioner", bytes);
+  }
+
+  Cassandra_describe_partitioner_result result;
+  try {
+    iface_->describe_partitioner(result.success);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_partitioner");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_partitioner", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_partitioner");
+  }
+
+  oprot->writeMessageBegin("describe_partitioner", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_partitioner", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_snitch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_snitch", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_snitch");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_snitch");
+  }
+
+  Cassandra_describe_snitch_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_snitch", bytes);
+  }
+
+  Cassandra_describe_snitch_result result;
+  try {
+    iface_->describe_snitch(result.success);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_snitch");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_snitch", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_snitch");
+  }
+
+  oprot->writeMessageBegin("describe_snitch", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_snitch", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_keyspace", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_keyspace");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_keyspace");
+  }
+
+  Cassandra_describe_keyspace_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_keyspace", bytes);
+  }
+
+  Cassandra_describe_keyspace_result result;
+  try {
+    iface_->describe_keyspace(result.success, args.keyspace);
+    result.__isset.success = true;
+  } catch (NotFoundException &nfe) {
+    result.nfe = nfe;
+    result.__isset.nfe = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_keyspace");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_keyspace");
+  }
+
+  oprot->writeMessageBegin("describe_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_keyspace", bytes);
+  }
+}
+
+void CassandraProcessor::process_describe_splits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.describe_splits", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.describe_splits");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.describe_splits");
+  }
+
+  Cassandra_describe_splits_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.describe_splits", bytes);
+  }
+
+  Cassandra_describe_splits_result result;
+  try {
+    iface_->describe_splits(result.success, args.cfName, args.start_token, args.end_token, args.keys_per_split);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.describe_splits");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("describe_splits", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.describe_splits");
+  }
+
+  oprot->writeMessageBegin("describe_splits", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.describe_splits", bytes);
+  }
+}
+
+void CassandraProcessor::process_system_add_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.system_add_column_family", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.system_add_column_family");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.system_add_column_family");
+  }
+
+  Cassandra_system_add_column_family_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.system_add_column_family", bytes);
+  }
+
+  Cassandra_system_add_column_family_result result;
+  try {
+    iface_->system_add_column_family(result.success, args.cf_def);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.system_add_column_family");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("system_add_column_family", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.system_add_column_family");
+  }
+
+  oprot->writeMessageBegin("system_add_column_family", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.system_add_column_family", bytes);
+  }
+}
+
+void CassandraProcessor::process_system_drop_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.system_drop_column_family", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.system_drop_column_family");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.system_drop_column_family");
+  }
+
+  Cassandra_system_drop_column_family_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.system_drop_column_family", bytes);
+  }
+
+  Cassandra_system_drop_column_family_result result;
+  try {
+    iface_->system_drop_column_family(result.success, args.column_family);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.system_drop_column_family");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("system_drop_column_family", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.system_drop_column_family");
+  }
+
+  oprot->writeMessageBegin("system_drop_column_family", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.system_drop_column_family", bytes);
+  }
+}
+
+void CassandraProcessor::process_system_add_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.system_add_keyspace", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.system_add_keyspace");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.system_add_keyspace");
+  }
+
+  Cassandra_system_add_keyspace_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.system_add_keyspace", bytes);
+  }
+
+  Cassandra_system_add_keyspace_result result;
+  try {
+    iface_->system_add_keyspace(result.success, args.ks_def);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.system_add_keyspace");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("system_add_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.system_add_keyspace");
+  }
+
+  oprot->writeMessageBegin("system_add_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.system_add_keyspace", bytes);
+  }
+}
+
+void CassandraProcessor::process_system_drop_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.system_drop_keyspace", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.system_drop_keyspace");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.system_drop_keyspace");
+  }
+
+  Cassandra_system_drop_keyspace_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.system_drop_keyspace", bytes);
+  }
+
+  Cassandra_system_drop_keyspace_result result;
+  try {
+    iface_->system_drop_keyspace(result.success, args.keyspace);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.system_drop_keyspace");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("system_drop_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.system_drop_keyspace");
+  }
+
+  oprot->writeMessageBegin("system_drop_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.system_drop_keyspace", bytes);
+  }
+}
+
+void CassandraProcessor::process_system_update_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.system_update_keyspace", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.system_update_keyspace");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.system_update_keyspace");
+  }
+
+  Cassandra_system_update_keyspace_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.system_update_keyspace", bytes);
+  }
+
+  Cassandra_system_update_keyspace_result result;
+  try {
+    iface_->system_update_keyspace(result.success, args.ks_def);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.system_update_keyspace");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("system_update_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.system_update_keyspace");
+  }
+
+  oprot->writeMessageBegin("system_update_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.system_update_keyspace", bytes);
+  }
+}
+
+void CassandraProcessor::process_system_update_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.system_update_column_family", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.system_update_column_family");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.system_update_column_family");
+  }
+
+  Cassandra_system_update_column_family_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.system_update_column_family", bytes);
+  }
+
+  Cassandra_system_update_column_family_result result;
+  try {
+    iface_->system_update_column_family(result.success, args.cf_def);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.system_update_column_family");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("system_update_column_family", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.system_update_column_family");
+  }
+
+  oprot->writeMessageBegin("system_update_column_family", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.system_update_column_family", bytes);
+  }
+}
+
+void CassandraProcessor::process_execute_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.execute_cql_query", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.execute_cql_query");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.execute_cql_query");
+  }
+
+  Cassandra_execute_cql_query_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.execute_cql_query", bytes);
+  }
+
+  Cassandra_execute_cql_query_result result;
+  try {
+    iface_->execute_cql_query(result.success, args.query, args.compression);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.execute_cql_query");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("execute_cql_query", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.execute_cql_query");
+  }
+
+  oprot->writeMessageBegin("execute_cql_query", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.execute_cql_query", bytes);
+  }
+}
+
+void CassandraProcessor::process_prepare_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.prepare_cql_query", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.prepare_cql_query");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.prepare_cql_query");
+  }
+
+  Cassandra_prepare_cql_query_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.prepare_cql_query", bytes);
+  }
+
+  Cassandra_prepare_cql_query_result result;
+  try {
+    iface_->prepare_cql_query(result.success, args.query, args.compression);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.prepare_cql_query");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("prepare_cql_query", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.prepare_cql_query");
+  }
+
+  oprot->writeMessageBegin("prepare_cql_query", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.prepare_cql_query", bytes);
+  }
+}
+
+void CassandraProcessor::process_execute_prepared_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.execute_prepared_cql_query", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.execute_prepared_cql_query");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.execute_prepared_cql_query");
+  }
+
+  Cassandra_execute_prepared_cql_query_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.execute_prepared_cql_query", bytes);
+  }
+
+  Cassandra_execute_prepared_cql_query_result result;
+  try {
+    iface_->execute_prepared_cql_query(result.success, args.itemId, args.values);
+    result.__isset.success = true;
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (UnavailableException &ue) {
+    result.ue = ue;
+    result.__isset.ue = true;
+  } catch (TimedOutException &te) {
+    result.te = te;
+    result.__isset.te = true;
+  } catch (SchemaDisagreementException &sde) {
+    result.sde = sde;
+    result.__isset.sde = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.execute_prepared_cql_query");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("execute_prepared_cql_query", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.execute_prepared_cql_query");
+  }
+
+  oprot->writeMessageBegin("execute_prepared_cql_query", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.execute_prepared_cql_query", bytes);
+  }
+}
+
+void CassandraProcessor::process_set_cql_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Cassandra.set_cql_version", callContext);
+  }
+  apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Cassandra.set_cql_version");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Cassandra.set_cql_version");
+  }
+
+  Cassandra_set_cql_version_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Cassandra.set_cql_version", bytes);
+  }
+
+  Cassandra_set_cql_version_result result;
+  try {
+    iface_->set_cql_version(args.version);
+  } catch (InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Cassandra.set_cql_version");
+    }
+
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("set_cql_version", apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Cassandra.set_cql_version");
+  }
+
+  oprot->writeMessageBegin("set_cql_version", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Cassandra.set_cql_version", bytes);
+  }
+}
+
+::boost::shared_ptr< ::apache::thrift::TProcessor > CassandraProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
+  ::apache::thrift::ReleaseHandler< CassandraIfFactory > cleanup(handlerFactory_);
+  ::boost::shared_ptr< CassandraIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
+  ::boost::shared_ptr< ::apache::thrift::TProcessor > processor(new CassandraProcessor(handler));
+  return processor;
+}
+CassandraAsyncIf::login_result CassandraAsyncIf::login_failure(apache::thrift::TApplicationException failure)
+{
+  login_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::login_result CassandraAsyncIf::login_authnx(AuthenticationException authnx)
+{
+  login_result result;
+  result.authnx = authnx;
+  result.__isset.authnx = true;
+  return result;
+}
+
+CassandraAsyncIf::login_result CassandraAsyncIf::login_authzx(AuthorizationException authzx)
+{
+  login_result result;
+  result.authzx = authzx;
+  result.__isset.authzx = true;
+  return result;
+}
+
+CassandraAsyncIf::set_keyspace_result CassandraAsyncIf::set_keyspace_failure(apache::thrift::TApplicationException failure)
+{
+  set_keyspace_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::set_keyspace_result CassandraAsyncIf::set_keyspace_ire(InvalidRequestException ire)
+{
+  set_keyspace_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::get_result CassandraAsyncIf::get_failure(apache::thrift::TApplicationException failure)
+{
+  get_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::get_result CassandraAsyncIf::get_success(ColumnOrSuperColumn success)
+{
+  get_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::get_result CassandraAsyncIf::get_ire(InvalidRequestException ire)
+{
+  get_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::get_result CassandraAsyncIf::get_nfe(NotFoundException nfe)
+{
+  get_result result;
+  result.nfe = nfe;
+  result.__isset.nfe = true;
+  return result;
+}
+
+CassandraAsyncIf::get_result CassandraAsyncIf::get_ue(UnavailableException ue)
+{
+  get_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::get_result CassandraAsyncIf::get_te(TimedOutException te)
+{
+  get_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::get_slice_result CassandraAsyncIf::get_slice_failure(apache::thrift::TApplicationException failure)
+{
+  get_slice_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::get_slice_result CassandraAsyncIf::get_slice_success(std::vector<ColumnOrSuperColumn>  success)
+{
+  get_slice_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::get_slice_result CassandraAsyncIf::get_slice_ire(InvalidRequestException ire)
+{
+  get_slice_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::get_slice_result CassandraAsyncIf::get_slice_ue(UnavailableException ue)
+{
+  get_slice_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::get_slice_result CassandraAsyncIf::get_slice_te(TimedOutException te)
+{
+  get_slice_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::get_count_result CassandraAsyncIf::get_count_failure(apache::thrift::TApplicationException failure)
+{
+  get_count_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::get_count_result CassandraAsyncIf::get_count_success(int32_t success)
+{
+  get_count_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::get_count_result CassandraAsyncIf::get_count_ire(InvalidRequestException ire)
+{
+  get_count_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::get_count_result CassandraAsyncIf::get_count_ue(UnavailableException ue)
+{
+  get_count_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::get_count_result CassandraAsyncIf::get_count_te(TimedOutException te)
+{
+  get_count_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_slice_result CassandraAsyncIf::multiget_slice_failure(apache::thrift::TApplicationException failure)
+{
+  multiget_slice_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_slice_result CassandraAsyncIf::multiget_slice_success(std::map<std::string, std::vector<ColumnOrSuperColumn> >  success)
+{
+  multiget_slice_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_slice_result CassandraAsyncIf::multiget_slice_ire(InvalidRequestException ire)
+{
+  multiget_slice_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_slice_result CassandraAsyncIf::multiget_slice_ue(UnavailableException ue)
+{
+  multiget_slice_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_slice_result CassandraAsyncIf::multiget_slice_te(TimedOutException te)
+{
+  multiget_slice_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_count_result CassandraAsyncIf::multiget_count_failure(apache::thrift::TApplicationException failure)
+{
+  multiget_count_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_count_result CassandraAsyncIf::multiget_count_success(std::map<std::string, int32_t>  success)
+{
+  multiget_count_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_count_result CassandraAsyncIf::multiget_count_ire(InvalidRequestException ire)
+{
+  multiget_count_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_count_result CassandraAsyncIf::multiget_count_ue(UnavailableException ue)
+{
+  multiget_count_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::multiget_count_result CassandraAsyncIf::multiget_count_te(TimedOutException te)
+{
+  multiget_count_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::get_range_slices_result CassandraAsyncIf::get_range_slices_failure(apache::thrift::TApplicationException failure)
+{
+  get_range_slices_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::get_range_slices_result CassandraAsyncIf::get_range_slices_success(std::vector<KeySlice>  success)
+{
+  get_range_slices_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::get_range_slices_result CassandraAsyncIf::get_range_slices_ire(InvalidRequestException ire)
+{
+  get_range_slices_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::get_range_slices_result CassandraAsyncIf::get_range_slices_ue(UnavailableException ue)
+{
+  get_range_slices_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::get_range_slices_result CassandraAsyncIf::get_range_slices_te(TimedOutException te)
+{
+  get_range_slices_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::get_paged_slice_result CassandraAsyncIf::get_paged_slice_failure(apache::thrift::TApplicationException failure)
+{
+  get_paged_slice_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::get_paged_slice_result CassandraAsyncIf::get_paged_slice_success(std::vector<KeySlice>  success)
+{
+  get_paged_slice_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::get_paged_slice_result CassandraAsyncIf::get_paged_slice_ire(InvalidRequestException ire)
+{
+  get_paged_slice_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::get_paged_slice_result CassandraAsyncIf::get_paged_slice_ue(UnavailableException ue)
+{
+  get_paged_slice_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::get_paged_slice_result CassandraAsyncIf::get_paged_slice_te(TimedOutException te)
+{
+  get_paged_slice_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::get_indexed_slices_result CassandraAsyncIf::get_indexed_slices_failure(apache::thrift::TApplicationException failure)
+{
+  get_indexed_slices_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::get_indexed_slices_result CassandraAsyncIf::get_indexed_slices_success(std::vector<KeySlice>  success)
+{
+  get_indexed_slices_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::get_indexed_slices_result CassandraAsyncIf::get_indexed_slices_ire(InvalidRequestException ire)
+{
+  get_indexed_slices_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::get_indexed_slices_result CassandraAsyncIf::get_indexed_slices_ue(UnavailableException ue)
+{
+  get_indexed_slices_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::get_indexed_slices_result CassandraAsyncIf::get_indexed_slices_te(TimedOutException te)
+{
+  get_indexed_slices_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::insert_result CassandraAsyncIf::insert_failure(apache::thrift::TApplicationException failure)
+{
+  insert_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::insert_result CassandraAsyncIf::insert_ire(InvalidRequestException ire)
+{
+  insert_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::insert_result CassandraAsyncIf::insert_ue(UnavailableException ue)
+{
+  insert_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::insert_result CassandraAsyncIf::insert_te(TimedOutException te)
+{
+  insert_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::add_result CassandraAsyncIf::add_failure(apache::thrift::TApplicationException failure)
+{
+  add_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::add_result CassandraAsyncIf::add_ire(InvalidRequestException ire)
+{
+  add_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::add_result CassandraAsyncIf::add_ue(UnavailableException ue)
+{
+  add_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::add_result CassandraAsyncIf::add_te(TimedOutException te)
+{
+  add_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_result CassandraAsyncIf::remove_failure(apache::thrift::TApplicationException failure)
+{
+  remove_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_result CassandraAsyncIf::remove_ire(InvalidRequestException ire)
+{
+  remove_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_result CassandraAsyncIf::remove_ue(UnavailableException ue)
+{
+  remove_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_result CassandraAsyncIf::remove_te(TimedOutException te)
+{
+  remove_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_counter_result CassandraAsyncIf::remove_counter_failure(apache::thrift::TApplicationException failure)
+{
+  remove_counter_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_counter_result CassandraAsyncIf::remove_counter_ire(InvalidRequestException ire)
+{
+  remove_counter_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_counter_result CassandraAsyncIf::remove_counter_ue(UnavailableException ue)
+{
+  remove_counter_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::remove_counter_result CassandraAsyncIf::remove_counter_te(TimedOutException te)
+{
+  remove_counter_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::batch_mutate_result CassandraAsyncIf::batch_mutate_failure(apache::thrift::TApplicationException failure)
+{
+  batch_mutate_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::batch_mutate_result CassandraAsyncIf::batch_mutate_ire(InvalidRequestException ire)
+{
+  batch_mutate_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::batch_mutate_result CassandraAsyncIf::batch_mutate_ue(UnavailableException ue)
+{
+  batch_mutate_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::batch_mutate_result CassandraAsyncIf::batch_mutate_te(TimedOutException te)
+{
+  batch_mutate_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::truncate_result CassandraAsyncIf::truncate_failure(apache::thrift::TApplicationException failure)
+{
+  truncate_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::truncate_result CassandraAsyncIf::truncate_ire(InvalidRequestException ire)
+{
+  truncate_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::truncate_result CassandraAsyncIf::truncate_ue(UnavailableException ue)
+{
+  truncate_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::truncate_result CassandraAsyncIf::truncate_te(TimedOutException te)
+{
+  truncate_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_schema_versions_result CassandraAsyncIf::describe_schema_versions_failure(apache::thrift::TApplicationException failure)
+{
+  describe_schema_versions_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_schema_versions_result CassandraAsyncIf::describe_schema_versions_success(std::map<std::string, std::vector<std::string> >  success)
+{
+  describe_schema_versions_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_schema_versions_result CassandraAsyncIf::describe_schema_versions_ire(InvalidRequestException ire)
+{
+  describe_schema_versions_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_keyspaces_result CassandraAsyncIf::describe_keyspaces_failure(apache::thrift::TApplicationException failure)
+{
+  describe_keyspaces_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_keyspaces_result CassandraAsyncIf::describe_keyspaces_success(std::vector<KsDef>  success)
+{
+  describe_keyspaces_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_keyspaces_result CassandraAsyncIf::describe_keyspaces_ire(InvalidRequestException ire)
+{
+  describe_keyspaces_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_cluster_name_result CassandraAsyncIf::describe_cluster_name_failure(apache::thrift::TApplicationException failure)
+{
+  describe_cluster_name_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_cluster_name_result CassandraAsyncIf::describe_cluster_name_success(std::string success)
+{
+  describe_cluster_name_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_version_result CassandraAsyncIf::describe_version_failure(apache::thrift::TApplicationException failure)
+{
+  describe_version_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_version_result CassandraAsyncIf::describe_version_success(std::string success)
+{
+  describe_version_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_ring_result CassandraAsyncIf::describe_ring_failure(apache::thrift::TApplicationException failure)
+{
+  describe_ring_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_ring_result CassandraAsyncIf::describe_ring_success(std::vector<TokenRange>  success)
+{
+  describe_ring_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_ring_result CassandraAsyncIf::describe_ring_ire(InvalidRequestException ire)
+{
+  describe_ring_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_token_map_result CassandraAsyncIf::describe_token_map_failure(apache::thrift::TApplicationException failure)
+{
+  describe_token_map_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_token_map_result CassandraAsyncIf::describe_token_map_success(std::map<std::string, std::string>  success)
+{
+  describe_token_map_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_token_map_result CassandraAsyncIf::describe_token_map_ire(InvalidRequestException ire)
+{
+  describe_token_map_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_partitioner_result CassandraAsyncIf::describe_partitioner_failure(apache::thrift::TApplicationException failure)
+{
+  describe_partitioner_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_partitioner_result CassandraAsyncIf::describe_partitioner_success(std::string success)
+{
+  describe_partitioner_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_snitch_result CassandraAsyncIf::describe_snitch_failure(apache::thrift::TApplicationException failure)
+{
+  describe_snitch_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_snitch_result CassandraAsyncIf::describe_snitch_success(std::string success)
+{
+  describe_snitch_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_keyspace_result CassandraAsyncIf::describe_keyspace_failure(apache::thrift::TApplicationException failure)
+{
+  describe_keyspace_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_keyspace_result CassandraAsyncIf::describe_keyspace_success(KsDef success)
+{
+  describe_keyspace_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_keyspace_result CassandraAsyncIf::describe_keyspace_nfe(NotFoundException nfe)
+{
+  describe_keyspace_result result;
+  result.nfe = nfe;
+  result.__isset.nfe = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_keyspace_result CassandraAsyncIf::describe_keyspace_ire(InvalidRequestException ire)
+{
+  describe_keyspace_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_splits_result CassandraAsyncIf::describe_splits_failure(apache::thrift::TApplicationException failure)
+{
+  describe_splits_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_splits_result CassandraAsyncIf::describe_splits_success(std::vector<std::string>  success)
+{
+  describe_splits_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::describe_splits_result CassandraAsyncIf::describe_splits_ire(InvalidRequestException ire)
+{
+  describe_splits_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_column_family_result CassandraAsyncIf::system_add_column_family_failure(apache::thrift::TApplicationException failure)
+{
+  system_add_column_family_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_column_family_result CassandraAsyncIf::system_add_column_family_success(std::string success)
+{
+  system_add_column_family_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_column_family_result CassandraAsyncIf::system_add_column_family_ire(InvalidRequestException ire)
+{
+  system_add_column_family_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_column_family_result CassandraAsyncIf::system_add_column_family_sde(SchemaDisagreementException sde)
+{
+  system_add_column_family_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_column_family_result CassandraAsyncIf::system_drop_column_family_failure(apache::thrift::TApplicationException failure)
+{
+  system_drop_column_family_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_column_family_result CassandraAsyncIf::system_drop_column_family_success(std::string success)
+{
+  system_drop_column_family_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_column_family_result CassandraAsyncIf::system_drop_column_family_ire(InvalidRequestException ire)
+{
+  system_drop_column_family_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_column_family_result CassandraAsyncIf::system_drop_column_family_sde(SchemaDisagreementException sde)
+{
+  system_drop_column_family_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_keyspace_result CassandraAsyncIf::system_add_keyspace_failure(apache::thrift::TApplicationException failure)
+{
+  system_add_keyspace_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_keyspace_result CassandraAsyncIf::system_add_keyspace_success(std::string success)
+{
+  system_add_keyspace_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_keyspace_result CassandraAsyncIf::system_add_keyspace_ire(InvalidRequestException ire)
+{
+  system_add_keyspace_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::system_add_keyspace_result CassandraAsyncIf::system_add_keyspace_sde(SchemaDisagreementException sde)
+{
+  system_add_keyspace_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_keyspace_result CassandraAsyncIf::system_drop_keyspace_failure(apache::thrift::TApplicationException failure)
+{
+  system_drop_keyspace_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_keyspace_result CassandraAsyncIf::system_drop_keyspace_success(std::string success)
+{
+  system_drop_keyspace_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_keyspace_result CassandraAsyncIf::system_drop_keyspace_ire(InvalidRequestException ire)
+{
+  system_drop_keyspace_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::system_drop_keyspace_result CassandraAsyncIf::system_drop_keyspace_sde(SchemaDisagreementException sde)
+{
+  system_drop_keyspace_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_keyspace_result CassandraAsyncIf::system_update_keyspace_failure(apache::thrift::TApplicationException failure)
+{
+  system_update_keyspace_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_keyspace_result CassandraAsyncIf::system_update_keyspace_success(std::string success)
+{
+  system_update_keyspace_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_keyspace_result CassandraAsyncIf::system_update_keyspace_ire(InvalidRequestException ire)
+{
+  system_update_keyspace_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_keyspace_result CassandraAsyncIf::system_update_keyspace_sde(SchemaDisagreementException sde)
+{
+  system_update_keyspace_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_column_family_result CassandraAsyncIf::system_update_column_family_failure(apache::thrift::TApplicationException failure)
+{
+  system_update_column_family_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_column_family_result CassandraAsyncIf::system_update_column_family_success(std::string success)
+{
+  system_update_column_family_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_column_family_result CassandraAsyncIf::system_update_column_family_ire(InvalidRequestException ire)
+{
+  system_update_column_family_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::system_update_column_family_result CassandraAsyncIf::system_update_column_family_sde(SchemaDisagreementException sde)
+{
+  system_update_column_family_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_cql_query_result CassandraAsyncIf::execute_cql_query_failure(apache::thrift::TApplicationException failure)
+{
+  execute_cql_query_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_cql_query_result CassandraAsyncIf::execute_cql_query_success(CqlResult success)
+{
+  execute_cql_query_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_cql_query_result CassandraAsyncIf::execute_cql_query_ire(InvalidRequestException ire)
+{
+  execute_cql_query_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_cql_query_result CassandraAsyncIf::execute_cql_query_ue(UnavailableException ue)
+{
+  execute_cql_query_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_cql_query_result CassandraAsyncIf::execute_cql_query_te(TimedOutException te)
+{
+  execute_cql_query_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_cql_query_result CassandraAsyncIf::execute_cql_query_sde(SchemaDisagreementException sde)
+{
+  execute_cql_query_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::prepare_cql_query_result CassandraAsyncIf::prepare_cql_query_failure(apache::thrift::TApplicationException failure)
+{
+  prepare_cql_query_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::prepare_cql_query_result CassandraAsyncIf::prepare_cql_query_success(CqlPreparedResult success)
+{
+  prepare_cql_query_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::prepare_cql_query_result CassandraAsyncIf::prepare_cql_query_ire(InvalidRequestException ire)
+{
+  prepare_cql_query_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_prepared_cql_query_result CassandraAsyncIf::execute_prepared_cql_query_failure(apache::thrift::TApplicationException failure)
+{
+  execute_prepared_cql_query_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_prepared_cql_query_result CassandraAsyncIf::execute_prepared_cql_query_success(CqlResult success)
+{
+  execute_prepared_cql_query_result result;
+  result.success = success;
+  result.__isset.success = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_prepared_cql_query_result CassandraAsyncIf::execute_prepared_cql_query_ire(InvalidRequestException ire)
+{
+  execute_prepared_cql_query_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_prepared_cql_query_result CassandraAsyncIf::execute_prepared_cql_query_ue(UnavailableException ue)
+{
+  execute_prepared_cql_query_result result;
+  result.ue = ue;
+  result.__isset.ue = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_prepared_cql_query_result CassandraAsyncIf::execute_prepared_cql_query_te(TimedOutException te)
+{
+  execute_prepared_cql_query_result result;
+  result.te = te;
+  result.__isset.te = true;
+  return result;
+}
+
+CassandraAsyncIf::execute_prepared_cql_query_result CassandraAsyncIf::execute_prepared_cql_query_sde(SchemaDisagreementException sde)
+{
+  execute_prepared_cql_query_result result;
+  result.sde = sde;
+  result.__isset.sde = true;
+  return result;
+}
+
+CassandraAsyncIf::set_cql_version_result CassandraAsyncIf::set_cql_version_failure(apache::thrift::TApplicationException failure)
+{
+  set_cql_version_result result;
+  result.failure = failure;
+  result.__isset.failure = true;
+  return result;
+}
+
+CassandraAsyncIf::set_cql_version_result CassandraAsyncIf::set_cql_version_ire(InvalidRequestException ire)
+{
+  set_cql_version_result result;
+  result.ire = ire;
+  result.__isset.ire = true;
+  return result;
+}
+
+CassandraAsyncIf::login_shared_future_t CassandraAsyncClient::login(const AuthenticationRequest& auth_request)
+{
+  send_login(auth_request);
+  login_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_login, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_login(const AuthenticationRequest& auth_request)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("login", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_login_pargs args;
+  args.auth_request = &auth_request;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_login(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, login_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(login_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(login_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("login") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(login_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_login_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.authnx) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.authzx) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::set_keyspace_shared_future_t CassandraAsyncClient::set_keyspace(const std::string& keyspace)
+{
+  send_set_keyspace(keyspace);
+  set_keyspace_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_set_keyspace, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_set_keyspace(const std::string& keyspace)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("set_keyspace", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_set_keyspace_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_set_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, set_keyspace_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(set_keyspace_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(set_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("set_keyspace") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(set_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_set_keyspace_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::get_shared_future_t CassandraAsyncClient::get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level)
+{
+  send_get(key, column_path, consistency_level);
+  get_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_get, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("get", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_pargs args;
+  args.key = &key;
+  args.column_path = &column_path;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_get(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("get") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_get_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.nfe) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(get_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::get_slice_shared_future_t CassandraAsyncClient::get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_get_slice(key, column_parent, predicate, consistency_level);
+  get_slice_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_get_slice, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("get_slice", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_slice_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_get_slice(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_slice_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_slice_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("get_slice") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_get_slice_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(get_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_slice failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::get_count_shared_future_t CassandraAsyncClient::get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_get_count(key, column_parent, predicate, consistency_level);
+  get_count_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_get_count, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("get_count", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_count_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_get_count(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_count_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_count_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_count_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("get_count") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_count_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  int32_t _return;
+  Cassandra_get_count_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(get_count_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_count failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::multiget_slice_shared_future_t CassandraAsyncClient::multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_multiget_slice(keys, column_parent, predicate, consistency_level);
+  multiget_slice_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_multiget_slice, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("multiget_slice", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_multiget_slice_pargs args;
+  args.keys = &keys;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_multiget_slice(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, multiget_slice_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(multiget_slice_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(multiget_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("multiget_slice") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(multiget_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_multiget_slice_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(multiget_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "multiget_slice failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::multiget_count_shared_future_t CassandraAsyncClient::multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_multiget_count(keys, column_parent, predicate, consistency_level);
+  multiget_count_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_multiget_count, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("multiget_count", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_multiget_count_pargs args;
+  args.keys = &keys;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_multiget_count(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, multiget_count_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(multiget_count_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(multiget_count_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("multiget_count") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(multiget_count_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_multiget_count_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(multiget_count_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "multiget_count failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::get_range_slices_shared_future_t CassandraAsyncClient::get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level)
+{
+  send_get_range_slices(column_parent, predicate, range, consistency_level);
+  get_range_slices_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_get_range_slices, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("get_range_slices", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_range_slices_pargs args;
+  args.column_parent = &column_parent;
+  args.predicate = &predicate;
+  args.range = &range;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_get_range_slices(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_range_slices_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_range_slices_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_range_slices_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("get_range_slices") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_range_slices_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_get_range_slices_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(get_range_slices_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_range_slices failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::get_paged_slice_shared_future_t CassandraAsyncClient::get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level)
+{
+  send_get_paged_slice(column_family, range, start_column, consistency_level);
+  get_paged_slice_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_get_paged_slice, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("get_paged_slice", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_paged_slice_pargs args;
+  args.column_family = &column_family;
+  args.range = &range;
+  args.start_column = &start_column;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_get_paged_slice(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_paged_slice_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_paged_slice_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_paged_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("get_paged_slice") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_paged_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_get_paged_slice_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(get_paged_slice_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_paged_slice failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::get_indexed_slices_shared_future_t CassandraAsyncClient::get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level)
+{
+  send_get_indexed_slices(column_parent, index_clause, column_predicate, consistency_level);
+  get_indexed_slices_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_get_indexed_slices, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("get_indexed_slices", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_get_indexed_slices_pargs 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->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_get_indexed_slices(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_indexed_slices_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_indexed_slices_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_indexed_slices_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("get_indexed_slices") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(get_indexed_slices_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_get_indexed_slices_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(get_indexed_slices_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_indexed_slices failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::insert_shared_future_t CassandraAsyncClient::insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level)
+{
+  send_insert(key, column_parent, column, consistency_level);
+  insert_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_insert, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("insert", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_insert_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.column = &column;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_insert(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, insert_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(insert_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(insert_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("insert") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(insert_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_insert_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::add_shared_future_t CassandraAsyncClient::add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level)
+{
+  send_add(key, column_parent, column, consistency_level);
+  add_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_add, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("add", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_add_pargs args;
+  args.key = &key;
+  args.column_parent = &column_parent;
+  args.column = &column;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_add(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, add_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(add_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(add_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("add") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(add_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_add_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::remove_shared_future_t CassandraAsyncClient::remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level)
+{
+  send_remove(key, column_path, timestamp, consistency_level);
+  remove_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_remove, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("remove", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_remove_pargs args;
+  args.key = &key;
+  args.column_path = &column_path;
+  args.timestamp = &timestamp;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_remove(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, remove_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(remove_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(remove_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("remove") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(remove_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_remove_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::remove_counter_shared_future_t CassandraAsyncClient::remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level)
+{
+  send_remove_counter(key, path, consistency_level);
+  remove_counter_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_remove_counter, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("remove_counter", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_remove_counter_pargs args;
+  args.key = &key;
+  args.path = &path;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_remove_counter(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, remove_counter_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(remove_counter_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(remove_counter_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("remove_counter") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(remove_counter_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_remove_counter_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::batch_mutate_shared_future_t CassandraAsyncClient::batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level)
+{
+  send_batch_mutate(mutation_map, consistency_level);
+  batch_mutate_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_batch_mutate, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("batch_mutate", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_batch_mutate_pargs args;
+  args.mutation_map = &mutation_map;
+  args.consistency_level = &consistency_level;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_batch_mutate(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, batch_mutate_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(batch_mutate_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(batch_mutate_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("batch_mutate") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(batch_mutate_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_batch_mutate_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::truncate_shared_future_t CassandraAsyncClient::truncate(const std::string& cfname)
+{
+  send_truncate(cfname);
+  truncate_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_truncate, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_truncate(const std::string& cfname)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("truncate", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_truncate_pargs args;
+  args.cfname = &cfname;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_truncate(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, truncate_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(truncate_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(truncate_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("truncate") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(truncate_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_truncate_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+CassandraAsyncIf::describe_schema_versions_shared_future_t CassandraAsyncClient::describe_schema_versions()
+{
+  send_describe_schema_versions();
+  describe_schema_versions_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_schema_versions, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_schema_versions()
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_schema_versions", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_schema_versions_pargs args;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_schema_versions(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_schema_versions_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_schema_versions_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_schema_versions_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_schema_versions") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_schema_versions_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_schema_versions_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_schema_versions_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_schema_versions failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_keyspaces_shared_future_t CassandraAsyncClient::describe_keyspaces()
+{
+  send_describe_keyspaces();
+  describe_keyspaces_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_keyspaces, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_keyspaces()
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_keyspaces", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_keyspaces_pargs args;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_keyspaces(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_keyspaces_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_keyspaces_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_keyspaces_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_keyspaces") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_keyspaces_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_keyspaces_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_keyspaces_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_keyspaces failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_cluster_name_shared_future_t CassandraAsyncClient::describe_cluster_name()
+{
+  send_describe_cluster_name();
+  describe_cluster_name_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_cluster_name, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_cluster_name()
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_cluster_name", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_cluster_name_pargs args;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_cluster_name(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_cluster_name_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_cluster_name_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_cluster_name_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_cluster_name") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_cluster_name_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_cluster_name_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_cluster_name_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_cluster_name failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_version_shared_future_t CassandraAsyncClient::describe_version()
+{
+  send_describe_version();
+  describe_version_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_version, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_version()
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_version", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_version_pargs args;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_version(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_version_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_version_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_version_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_version") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_version_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_version_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_version_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_version failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_ring_shared_future_t CassandraAsyncClient::describe_ring(const std::string& keyspace)
+{
+  send_describe_ring(keyspace);
+  describe_ring_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_ring, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_ring(const std::string& keyspace)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_ring", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_ring_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_ring(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_ring_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_ring_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_ring_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_ring") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_ring_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_ring_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_ring_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_ring failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_token_map_shared_future_t CassandraAsyncClient::describe_token_map()
+{
+  send_describe_token_map();
+  describe_token_map_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_token_map, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_token_map()
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_token_map", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_token_map_pargs args;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_token_map(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_token_map_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_token_map_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_token_map_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_token_map") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_token_map_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_token_map_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_token_map_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_token_map failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_partitioner_shared_future_t CassandraAsyncClient::describe_partitioner()
+{
+  send_describe_partitioner();
+  describe_partitioner_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_partitioner, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_partitioner()
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_partitioner", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_partitioner_pargs args;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_partitioner(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_partitioner_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_partitioner_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_partitioner_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_partitioner") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_partitioner_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_partitioner_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_partitioner_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_partitioner failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_snitch_shared_future_t CassandraAsyncClient::describe_snitch()
+{
+  send_describe_snitch();
+  describe_snitch_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_snitch, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_snitch()
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_snitch", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_snitch_pargs args;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_snitch(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_snitch_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_snitch_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_snitch_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_snitch") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_snitch_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_snitch_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_snitch_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_snitch failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_keyspace_shared_future_t CassandraAsyncClient::describe_keyspace(const std::string& keyspace)
+{
+  send_describe_keyspace(keyspace);
+  describe_keyspace_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_keyspace, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_keyspace(const std::string& keyspace)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_keyspace", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_keyspace_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_keyspace_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_keyspace_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_keyspace") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_keyspace_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.nfe) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_keyspace failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::describe_splits_shared_future_t CassandraAsyncClient::describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split)
+{
+  send_describe_splits(cfName, start_token, end_token, keys_per_split);
+  describe_splits_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_describe_splits, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("describe_splits", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_describe_splits_pargs 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->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_describe_splits(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_splits_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_splits_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_splits_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("describe_splits") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(describe_splits_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_describe_splits_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(describe_splits_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "describe_splits failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::system_add_column_family_shared_future_t CassandraAsyncClient::system_add_column_family(const CfDef& cf_def)
+{
+  send_system_add_column_family(cf_def);
+  system_add_column_family_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_system_add_column_family, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_system_add_column_family(const CfDef& cf_def)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("system_add_column_family", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_add_column_family_pargs args;
+  args.cf_def = &cf_def;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_system_add_column_family(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_add_column_family_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_add_column_family_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_add_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("system_add_column_family") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_add_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_system_add_column_family_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(system_add_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "system_add_column_family failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::system_drop_column_family_shared_future_t CassandraAsyncClient::system_drop_column_family(const std::string& column_family)
+{
+  send_system_drop_column_family(column_family);
+  system_drop_column_family_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_system_drop_column_family, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_system_drop_column_family(const std::string& column_family)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("system_drop_column_family", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_drop_column_family_pargs args;
+  args.column_family = &column_family;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_system_drop_column_family(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_drop_column_family_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_drop_column_family_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_drop_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("system_drop_column_family") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_drop_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_system_drop_column_family_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(system_drop_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "system_drop_column_family failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::system_add_keyspace_shared_future_t CassandraAsyncClient::system_add_keyspace(const KsDef& ks_def)
+{
+  send_system_add_keyspace(ks_def);
+  system_add_keyspace_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_system_add_keyspace, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_system_add_keyspace(const KsDef& ks_def)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("system_add_keyspace", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_add_keyspace_pargs args;
+  args.ks_def = &ks_def;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_system_add_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_add_keyspace_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_add_keyspace_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_add_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("system_add_keyspace") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_add_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_system_add_keyspace_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(system_add_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "system_add_keyspace failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::system_drop_keyspace_shared_future_t CassandraAsyncClient::system_drop_keyspace(const std::string& keyspace)
+{
+  send_system_drop_keyspace(keyspace);
+  system_drop_keyspace_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_system_drop_keyspace, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_system_drop_keyspace(const std::string& keyspace)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("system_drop_keyspace", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_drop_keyspace_pargs args;
+  args.keyspace = &keyspace;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_system_drop_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_drop_keyspace_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_drop_keyspace_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_drop_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("system_drop_keyspace") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_drop_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_system_drop_keyspace_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(system_drop_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "system_drop_keyspace failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::system_update_keyspace_shared_future_t CassandraAsyncClient::system_update_keyspace(const KsDef& ks_def)
+{
+  send_system_update_keyspace(ks_def);
+  system_update_keyspace_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_system_update_keyspace, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_system_update_keyspace(const KsDef& ks_def)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("system_update_keyspace", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_update_keyspace_pargs args;
+  args.ks_def = &ks_def;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_system_update_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_update_keyspace_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_update_keyspace_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_update_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("system_update_keyspace") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_update_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_system_update_keyspace_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(system_update_keyspace_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "system_update_keyspace failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::system_update_column_family_shared_future_t CassandraAsyncClient::system_update_column_family(const CfDef& cf_def)
+{
+  send_system_update_column_family(cf_def);
+  system_update_column_family_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_system_update_column_family, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_system_update_column_family(const CfDef& cf_def)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("system_update_column_family", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_system_update_column_family_pargs args;
+  args.cf_def = &cf_def;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_system_update_column_family(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_update_column_family_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_update_column_family_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_update_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("system_update_column_family") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(system_update_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_system_update_column_family_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(system_update_column_family_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "system_update_column_family failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::execute_cql_query_shared_future_t CassandraAsyncClient::execute_cql_query(const std::string& query, const Compression::type compression)
+{
+  send_execute_cql_query(query, compression);
+  execute_cql_query_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_execute_cql_query, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_execute_cql_query(const std::string& query, const Compression::type compression)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("execute_cql_query", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_execute_cql_query_pargs args;
+  args.query = &query;
+  args.compression = &compression;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_execute_cql_query(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, execute_cql_query_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(execute_cql_query_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(execute_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("execute_cql_query") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(execute_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_execute_cql_query_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(execute_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "execute_cql_query failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::prepare_cql_query_shared_future_t CassandraAsyncClient::prepare_cql_query(const std::string& query, const Compression::type compression)
+{
+  send_prepare_cql_query(query, compression);
+  prepare_cql_query_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_prepare_cql_query, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_prepare_cql_query(const std::string& query, const Compression::type compression)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("prepare_cql_query", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_prepare_cql_query_pargs args;
+  args.query = &query;
+  args.compression = &compression;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_prepare_cql_query(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, prepare_cql_query_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(prepare_cql_query_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(prepare_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("prepare_cql_query") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(prepare_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_prepare_cql_query_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(prepare_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "prepare_cql_query failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::execute_prepared_cql_query_shared_future_t CassandraAsyncClient::execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values)
+{
+  send_execute_prepared_cql_query(itemId, values);
+  execute_prepared_cql_query_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_execute_prepared_cql_query, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("execute_prepared_cql_query", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_execute_prepared_cql_query_pargs args;
+  args.itemId = &itemId;
+  args.values = &values;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_execute_prepared_cql_query(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, execute_prepared_cql_query_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(execute_prepared_cql_query_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(execute_prepared_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("execute_prepared_cql_query") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(execute_prepared_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_execute_prepared_cql_query_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    promise.callback(result.success);
+    return;
+  }
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ue) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.te) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.sde) {
+    promise.errback(result);
+    return;
+  }
+    promise.errback(execute_prepared_cql_query_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "execute_prepared_cql_query failed: unknown result")));    return;
+}
+
+CassandraAsyncIf::set_cql_version_shared_future_t CassandraAsyncClient::set_cql_version(const std::string& version)
+{
+  send_set_cql_version(version);
+  set_cql_version_shared_promise_t promise;
+  apache::thrift::concurrency::Guard g(mutex_);
+  requests_[request_counter_] = boost::bind(&CassandraAsyncClient::recv_set_cql_version, this, _1 /* piprot */, _2 /* fname */, _3 /* mtype */, promise);
+  return promise;
+}
+
+void CassandraAsyncClient::send_set_cql_version(const std::string& version)
+{
+  boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot = oprotfact_->getProtocol(potransport_);
+  apache::thrift::protocol::TProtocol* oprot = poprot.get();
+  apache::thrift::concurrency::Guard g(mutex_); // for oprot and request_counter_
+  if (++request_counter_ < 0)
+    request_counter_ = 1;
+  int32_t cseqid = request_counter_;
+  oprot->writeMessageBegin("set_cql_version", apache::thrift::protocol::T_CALL, cseqid);
+
+  Cassandra_set_cql_version_pargs args;
+  args.version = &version;
+  args.write(oprot);
+
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncClient::recv_set_cql_version(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, set_cql_version_shared_promise_t promise)
+{
+
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot.get());
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(set_cql_version_failure(x));
+    return;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(set_cql_version_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE)));
+    return;
+  }
+  if (fname.compare("set_cql_version") != 0) {
+    iprot->skip(apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    promise.errback(set_cql_version_failure(apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME)));
+    return;
+  }
+  Cassandra_set_cql_version_result result;
+  result.read(iprot.get());
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  if (result.__isset.failure) {
+    promise.errback(result);
+    return;
+  }
+  if (result.__isset.ire) {
+    promise.errback(result);
+    return;
+  }
+  promise.callback();
+}
+
+bool CassandraAsyncClient::process(boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, void* connectionContext)
+{
+  std::string fname;
+  apache::thrift::protocol::TMessageType mtype;
+  int32_t rseqid;
+
+  piprot->readMessageBegin(fname, mtype, rseqid);
+  apache::thrift::concurrency::Guard g(mutex_);
+  request_map_t::iterator it = requests_.find(rseqid);
+  if (it == requests_.end()) return false;
+  it->second(piprot, fname, mtype); /* Invoke user method */
+  requests_.erase(it);
+  return true;
+}
+bool CassandraAsyncProcessor::process(boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, void* connectionContext) {
+
+  std::string fname;
+  apache::thrift::protocol::TMessageType mtype;
+  int32_t seqid;
+
+  piprot->readMessageBegin(fname, mtype, seqid);
+
+  if (mtype != apache::thrift::protocol::T_CALL && mtype != apache::thrift::protocol::T_ONEWAY) {
+    piprot->skip(apache::thrift::protocol::T_STRUCT);
+    piprot->readMessageEnd();
+    piprot->getTransport()->readEnd();
+    apache::thrift::TApplicationException x(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+    poprot->writeMessageBegin(fname, apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return true;
+  }
+
+  return process_fn(piprot, poprot, fname, seqid);
+}
+
+bool CassandraAsyncProcessor::process_fn(boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string& fname, int32_t seqid) {
+  std::map<std::string, void (CassandraAsyncProcessor::*)(int32_t, boost::shared_ptr<apache::thrift::protocol::TProtocol>, boost::shared_ptr<apache::thrift::protocol::TProtocol>)>::iterator pfn;
+  pfn = processMap_.find(fname);
+  if (pfn == processMap_.end()) {
+    piprot->skip(apache::thrift::protocol::T_STRUCT);
+    piprot->readMessageEnd();
+    piprot->getTransport()->readEnd();
+    apache::thrift::TApplicationException x(apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
+    poprot->writeMessageBegin(fname, apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return true;
+  }
+  (this->*(pfn->second))(seqid, piprot, poprot);
+  return true;
+}
+
+void CassandraAsyncProcessor::process_login(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_login_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::login_shared_future_t future = iface_->login(args.auth_request);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_login, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_login, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_login(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_login_result result;
+  reply_login(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_login(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_login_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("login", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("login", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_set_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_set_keyspace_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::set_keyspace_shared_future_t future = iface_->set_keyspace(args.keyspace);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_set_keyspace, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_set_keyspace, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_set_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_set_keyspace_result result;
+  reply_set_keyspace(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_set_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_set_keyspace_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("set_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("set_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_get(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_get_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::get_shared_future_t future = iface_->get(args.key, args.column_path, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_get, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_get, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_get(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, ColumnOrSuperColumn value)
+{
+  Cassandra_get_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_get(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_get(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("get", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("get", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_get_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_get_slice_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::get_slice_shared_future_t future = iface_->get_slice(args.key, args.column_parent, args.predicate, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_get_slice, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_get_slice, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_get_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<ColumnOrSuperColumn>  value)
+{
+  Cassandra_get_slice_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_get_slice(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_get_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_slice_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("get_slice", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("get_slice", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_get_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_get_count_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::get_count_shared_future_t future = iface_->get_count(args.key, args.column_parent, args.predicate, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_get_count, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_get_count, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_get_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, int32_t value)
+{
+  Cassandra_get_count_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_get_count(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_get_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_count_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("get_count", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("get_count", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_multiget_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_multiget_slice_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::multiget_slice_shared_future_t future = iface_->multiget_slice(args.keys, args.column_parent, args.predicate, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_multiget_slice, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_multiget_slice, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_multiget_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, std::vector<ColumnOrSuperColumn> >  value)
+{
+  Cassandra_multiget_slice_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_multiget_slice(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_multiget_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_multiget_slice_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("multiget_slice", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("multiget_slice", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_multiget_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_multiget_count_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::multiget_count_shared_future_t future = iface_->multiget_count(args.keys, args.column_parent, args.predicate, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_multiget_count, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_multiget_count, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_multiget_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, int32_t>  value)
+{
+  Cassandra_multiget_count_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_multiget_count(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_multiget_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_multiget_count_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("multiget_count", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("multiget_count", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_get_range_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_get_range_slices_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::get_range_slices_shared_future_t future = iface_->get_range_slices(args.column_parent, args.predicate, args.range, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_get_range_slices, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_get_range_slices, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_get_range_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KeySlice>  value)
+{
+  Cassandra_get_range_slices_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_get_range_slices(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_get_range_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_range_slices_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("get_range_slices", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("get_range_slices", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_get_paged_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_get_paged_slice_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::get_paged_slice_shared_future_t future = iface_->get_paged_slice(args.column_family, args.range, args.start_column, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_get_paged_slice, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_get_paged_slice, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_get_paged_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KeySlice>  value)
+{
+  Cassandra_get_paged_slice_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_get_paged_slice(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_get_paged_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_paged_slice_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("get_paged_slice", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("get_paged_slice", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_get_indexed_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_get_indexed_slices_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::get_indexed_slices_shared_future_t future = iface_->get_indexed_slices(args.column_parent, args.index_clause, args.column_predicate, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_get_indexed_slices, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_get_indexed_slices, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_get_indexed_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KeySlice>  value)
+{
+  Cassandra_get_indexed_slices_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_get_indexed_slices(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_get_indexed_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_indexed_slices_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("get_indexed_slices", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("get_indexed_slices", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_insert(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_insert_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::insert_shared_future_t future = iface_->insert(args.key, args.column_parent, args.column, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_insert, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_insert, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_insert(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_insert_result result;
+  reply_insert(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_insert(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_insert_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("insert", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("insert", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_add(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_add_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::add_shared_future_t future = iface_->add(args.key, args.column_parent, args.column, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_add, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_add, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_add(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_add_result result;
+  reply_add(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_add(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_add_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("add", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("add", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_remove(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_remove_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::remove_shared_future_t future = iface_->remove(args.key, args.column_path, args.timestamp, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_remove, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_remove, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_remove(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_remove_result result;
+  reply_remove(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_remove(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_remove_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("remove", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("remove", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_remove_counter(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_remove_counter_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::remove_counter_shared_future_t future = iface_->remove_counter(args.key, args.path, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_remove_counter, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_remove_counter, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_remove_counter(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_remove_counter_result result;
+  reply_remove_counter(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_remove_counter(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_remove_counter_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("remove_counter", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("remove_counter", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_batch_mutate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_batch_mutate_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::batch_mutate_shared_future_t future = iface_->batch_mutate(args.mutation_map, args.consistency_level);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_batch_mutate, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_batch_mutate, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_batch_mutate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_batch_mutate_result result;
+  reply_batch_mutate(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_batch_mutate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_batch_mutate_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("batch_mutate", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("batch_mutate", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_truncate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_truncate_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::truncate_shared_future_t future = iface_->truncate(args.cfname);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_truncate, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_truncate, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_truncate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_truncate_result result;
+  reply_truncate(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_truncate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_truncate_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("truncate", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("truncate", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_schema_versions(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_schema_versions_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_schema_versions_shared_future_t future = iface_->describe_schema_versions();
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_schema_versions, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_schema_versions, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_schema_versions(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, std::vector<std::string> >  value)
+{
+  Cassandra_describe_schema_versions_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_schema_versions(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_schema_versions(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_schema_versions_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_schema_versions", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_schema_versions", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_keyspaces(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_keyspaces_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_keyspaces_shared_future_t future = iface_->describe_keyspaces();
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_keyspaces, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_keyspaces, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_keyspaces(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KsDef>  value)
+{
+  Cassandra_describe_keyspaces_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_keyspaces(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_keyspaces(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_keyspaces_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_keyspaces", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_keyspaces", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_cluster_name(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_cluster_name_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_cluster_name_shared_future_t future = iface_->describe_cluster_name();
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_cluster_name, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_cluster_name, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_cluster_name(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_describe_cluster_name_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_cluster_name(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_cluster_name(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_cluster_name_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_cluster_name", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_cluster_name", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_version_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_version_shared_future_t future = iface_->describe_version();
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_version, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_version, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_describe_version_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_version(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_version_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_version", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_version", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_ring(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_ring_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_ring_shared_future_t future = iface_->describe_ring(args.keyspace);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_ring, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_ring, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_ring(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<TokenRange>  value)
+{
+  Cassandra_describe_ring_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_ring(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_ring(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_ring_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_ring", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_ring", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_token_map(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_token_map_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_token_map_shared_future_t future = iface_->describe_token_map();
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_token_map, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_token_map, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_token_map(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, std::string>  value)
+{
+  Cassandra_describe_token_map_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_token_map(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_token_map(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_token_map_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_token_map", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_token_map", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_partitioner(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_partitioner_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_partitioner_shared_future_t future = iface_->describe_partitioner();
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_partitioner, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_partitioner, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_partitioner(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_describe_partitioner_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_partitioner(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_partitioner(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_partitioner_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_partitioner", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_partitioner", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_snitch(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_snitch_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_snitch_shared_future_t future = iface_->describe_snitch();
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_snitch, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_snitch, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_snitch(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_describe_snitch_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_snitch(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_snitch(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_snitch_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_snitch", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_snitch", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_keyspace_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_keyspace_shared_future_t future = iface_->describe_keyspace(args.keyspace);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_keyspace, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_keyspace, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, KsDef value)
+{
+  Cassandra_describe_keyspace_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_keyspace(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_keyspace_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_describe_splits(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_describe_splits_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::describe_splits_shared_future_t future = iface_->describe_splits(args.cfName, args.start_token, args.end_token, args.keys_per_split);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_describe_splits, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_describe_splits, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_describe_splits(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<std::string>  value)
+{
+  Cassandra_describe_splits_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_describe_splits(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_describe_splits(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_splits_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("describe_splits", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("describe_splits", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_system_add_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_system_add_column_family_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::system_add_column_family_shared_future_t future = iface_->system_add_column_family(args.cf_def);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_system_add_column_family, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_system_add_column_family, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_system_add_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_system_add_column_family_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_system_add_column_family(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_system_add_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_add_column_family_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("system_add_column_family", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("system_add_column_family", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_system_drop_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_system_drop_column_family_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::system_drop_column_family_shared_future_t future = iface_->system_drop_column_family(args.column_family);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_system_drop_column_family, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_system_drop_column_family, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_system_drop_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_system_drop_column_family_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_system_drop_column_family(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_system_drop_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_drop_column_family_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("system_drop_column_family", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("system_drop_column_family", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_system_add_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_system_add_keyspace_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::system_add_keyspace_shared_future_t future = iface_->system_add_keyspace(args.ks_def);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_system_add_keyspace, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_system_add_keyspace, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_system_add_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_system_add_keyspace_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_system_add_keyspace(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_system_add_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_add_keyspace_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("system_add_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("system_add_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_system_drop_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_system_drop_keyspace_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::system_drop_keyspace_shared_future_t future = iface_->system_drop_keyspace(args.keyspace);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_system_drop_keyspace, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_system_drop_keyspace, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_system_drop_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_system_drop_keyspace_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_system_drop_keyspace(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_system_drop_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_drop_keyspace_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("system_drop_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("system_drop_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_system_update_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_system_update_keyspace_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::system_update_keyspace_shared_future_t future = iface_->system_update_keyspace(args.ks_def);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_system_update_keyspace, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_system_update_keyspace, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_system_update_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_system_update_keyspace_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_system_update_keyspace(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_system_update_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_update_keyspace_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("system_update_keyspace", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("system_update_keyspace", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_system_update_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_system_update_column_family_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::system_update_column_family_shared_future_t future = iface_->system_update_column_family(args.cf_def);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_system_update_column_family, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_system_update_column_family, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_system_update_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value)
+{
+  Cassandra_system_update_column_family_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_system_update_column_family(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_system_update_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_update_column_family_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("system_update_column_family", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("system_update_column_family", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_execute_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_execute_cql_query_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::execute_cql_query_shared_future_t future = iface_->execute_cql_query(args.query, args.compression);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_execute_cql_query, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_execute_cql_query, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_execute_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, CqlResult value)
+{
+  Cassandra_execute_cql_query_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_execute_cql_query(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_execute_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_execute_cql_query_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("execute_cql_query", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("execute_cql_query", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_prepare_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_prepare_cql_query_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::prepare_cql_query_shared_future_t future = iface_->prepare_cql_query(args.query, args.compression);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_prepare_cql_query, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_prepare_cql_query, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_prepare_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, CqlPreparedResult value)
+{
+  Cassandra_prepare_cql_query_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_prepare_cql_query(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_prepare_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_prepare_cql_query_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("prepare_cql_query", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("prepare_cql_query", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_execute_prepared_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_execute_prepared_cql_query_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::execute_prepared_cql_query_shared_future_t future = iface_->execute_prepared_cql_query(args.itemId, args.values);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_execute_prepared_cql_query, this, seqid, poprot, _1));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_execute_prepared_cql_query, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_execute_prepared_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, CqlResult value)
+{
+  Cassandra_execute_prepared_cql_query_result result;
+  result.success = value;
+  result.__isset.success = true;
+  reply_execute_prepared_cql_query(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_execute_prepared_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_execute_prepared_cql_query_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("execute_prepared_cql_query", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("execute_prepared_cql_query", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+void CassandraAsyncProcessor::process_set_cql_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_set_cql_version_args args;
+  args.read(piprot.get());
+  piprot->readMessageEnd();
+  piprot->getTransport()->readEnd();
+
+  CassandraAsyncIf::set_cql_version_shared_future_t future = iface_->set_cql_version(args.version);
+  future.setCallback(boost::bind(&CassandraAsyncProcessor::success_set_cql_version, this, seqid, poprot));
+  future.setErrback(boost::bind(&CassandraAsyncProcessor::reply_set_cql_version, this, seqid, poprot, _1));
+}
+
+void CassandraAsyncProcessor::success_set_cql_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot)
+{
+  Cassandra_set_cql_version_result result;
+  reply_set_cql_version(seqid, poprot, result);
+}
+
+void CassandraAsyncProcessor::reply_set_cql_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_set_cql_version_result result)
+{
+  if (result.__isset.failure) {
+    poprot->writeMessageBegin("set_cql_version", apache::thrift::protocol::T_EXCEPTION, seqid);
+    result.failure.write(poprot.get());
+    poprot->writeMessageEnd();
+    poprot->getTransport()->flush();
+    poprot->getTransport()->writeEnd();
+    return;
+  }
+
+  poprot->writeMessageBegin("set_cql_version", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(poprot.get());
+  poprot->writeMessageEnd();
+  poprot->getTransport()->flush();
+  poprot->getTransport()->writeEnd();
+}
+
+}}} // namespace
+

=== added file 'storage/cassandra/gen-cpp-async/Cassandra.h'
--- a/storage/cassandra/gen-cpp-async/Cassandra.h	1970-01-01 00:00:00 +0000
+++ b/storage/cassandra/gen-cpp-async/Cassandra.h	2012-09-20 14:32:37 +0000
@@ -0,0 +1,6487 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0-dev)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef Cassandra_H
+#define Cassandra_H
+
+#include <thrift/TDispatchProcessor.h>
+#include "cassandra_types.h"
+
+namespace org { namespace apache { namespace cassandra {
+
+// next line added by psergey
+namespace apache = ::apache;
+
+class CassandraIf {
+ public:
+  virtual ~CassandraIf() {}
+  virtual void login(const AuthenticationRequest& auth_request) = 0;
+  virtual void set_keyspace(const std::string& keyspace) = 0;
+  virtual void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) = 0;
+  virtual void truncate(const std::string& cfname) = 0;
+  virtual void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) = 0;
+  virtual void describe_keyspaces(std::vector<KsDef> & _return) = 0;
+  virtual void describe_cluster_name(std::string& _return) = 0;
+  virtual void describe_version(std::string& _return) = 0;
+  virtual void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) = 0;
+  virtual void describe_token_map(std::map<std::string, std::string> & _return) = 0;
+  virtual void describe_partitioner(std::string& _return) = 0;
+  virtual void describe_snitch(std::string& _return) = 0;
+  virtual void describe_keyspace(KsDef& _return, const std::string& keyspace) = 0;
+  virtual void describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) = 0;
+  virtual void system_add_column_family(std::string& _return, const CfDef& cf_def) = 0;
+  virtual void system_drop_column_family(std::string& _return, const std::string& column_family) = 0;
+  virtual void system_add_keyspace(std::string& _return, const KsDef& ks_def) = 0;
+  virtual void system_drop_keyspace(std::string& _return, const std::string& keyspace) = 0;
+  virtual void system_update_keyspace(std::string& _return, const KsDef& ks_def) = 0;
+  virtual void system_update_column_family(std::string& _return, const CfDef& cf_def) = 0;
+  virtual void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) = 0;
+  virtual void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression) = 0;
+  virtual void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values) = 0;
+  virtual void set_cql_version(const std::string& version) = 0;
+};
+
+class CassandraIfFactory {
+ public:
+  typedef CassandraIf Handler;
+
+  virtual ~CassandraIfFactory() {}
+
+  virtual CassandraIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(CassandraIf* /* handler */) = 0;
+};
+
+class CassandraIfSingletonFactory : virtual public CassandraIfFactory {
+ public:
+  CassandraIfSingletonFactory(const boost::shared_ptr<CassandraIf>& iface) : iface_(iface) {}
+  virtual ~CassandraIfSingletonFactory() {}
+
+  virtual CassandraIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(CassandraIf* /* handler */) {}
+
+ protected:
+  boost::shared_ptr<CassandraIf> iface_;
+};
+
+class CassandraNull : virtual public CassandraIf {
+ public:
+  virtual ~CassandraNull() {}
+  void login(const AuthenticationRequest& /* auth_request */) {
+    return;
+  }
+  void set_keyspace(const std::string& /* keyspace */) {
+    return;
+  }
+  void get(ColumnOrSuperColumn& /* _return */, const std::string& /* key */, const ColumnPath& /* column_path */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void get_slice(std::vector<ColumnOrSuperColumn> & /* _return */, const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  int32_t get_count(const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
+    int32_t _return = 0;
+    return _return;
+  }
+  void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & /* _return */, const std::vector<std::string> & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void multiget_count(std::map<std::string, int32_t> & /* _return */, const std::vector<std::string> & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void get_range_slices(std::vector<KeySlice> & /* _return */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const KeyRange& /* range */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void get_paged_slice(std::vector<KeySlice> & /* _return */, const std::string& /* column_family */, const KeyRange& /* range */, const std::string& /* start_column */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void get_indexed_slices(std::vector<KeySlice> & /* _return */, const ColumnParent& /* column_parent */, const IndexClause& /* index_clause */, const SlicePredicate& /* column_predicate */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void insert(const std::string& /* key */, const ColumnParent& /* column_parent */, const Column& /* column */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void add(const std::string& /* key */, const ColumnParent& /* column_parent */, const CounterColumn& /* column */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void remove(const std::string& /* key */, const ColumnPath& /* column_path */, const int64_t /* timestamp */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void remove_counter(const std::string& /* key */, const ColumnPath& /* path */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & /* mutation_map */, const ConsistencyLevel::type /* consistency_level */) {
+    return;
+  }
+  void truncate(const std::string& /* cfname */) {
+    return;
+  }
+  void describe_schema_versions(std::map<std::string, std::vector<std::string> > & /* _return */) {
+    return;
+  }
+  void describe_keyspaces(std::vector<KsDef> & /* _return */) {
+    return;
+  }
+  void describe_cluster_name(std::string& /* _return */) {
+    return;
+  }
+  void describe_version(std::string& /* _return */) {
+    return;
+  }
+  void describe_ring(std::vector<TokenRange> & /* _return */, const std::string& /* keyspace */) {
+    return;
+  }
+  void describe_token_map(std::map<std::string, std::string> & /* _return */) {
+    return;
+  }
+  void describe_partitioner(std::string& /* _return */) {
+    return;
+  }
+  void describe_snitch(std::string& /* _return */) {
+    return;
+  }
+  void describe_keyspace(KsDef& /* _return */, const std::string& /* keyspace */) {
+    return;
+  }
+  void describe_splits(std::vector<std::string> & /* _return */, const std::string& /* cfName */, const std::string& /* start_token */, const std::string& /* end_token */, const int32_t /* keys_per_split */) {
+    return;
+  }
+  void system_add_column_family(std::string& /* _return */, const CfDef& /* cf_def */) {
+    return;
+  }
+  void system_drop_column_family(std::string& /* _return */, const std::string& /* column_family */) {
+    return;
+  }
+  void system_add_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) {
+    return;
+  }
+  void system_drop_keyspace(std::string& /* _return */, const std::string& /* keyspace */) {
+    return;
+  }
+  void system_update_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) {
+    return;
+  }
+  void system_update_column_family(std::string& /* _return */, const CfDef& /* cf_def */) {
+    return;
+  }
+  void execute_cql_query(CqlResult& /* _return */, const std::string& /* query */, const Compression::type /* compression */) {
+    return;
+  }
+  void prepare_cql_query(CqlPreparedResult& /* _return */, const std::string& /* query */, const Compression::type /* compression */) {
+    return;
+  }
+  void execute_prepared_cql_query(CqlResult& /* _return */, const int32_t /* itemId */, const std::vector<std::string> & /* values */) {
+    return;
+  }
+  void set_cql_version(const std::string& /* version */) {
+    return;
+  }
+};
+
+
+class Cassandra_login_args {
+ public:
+
+  Cassandra_login_args() {
+  }
+
+  virtual ~Cassandra_login_args() throw() {}
+
+  AuthenticationRequest auth_request;
+
+  void __set_auth_request(const AuthenticationRequest& val) {
+    auth_request = val;
+  }
+
+  bool operator == (const Cassandra_login_args & rhs) const
+  {
+    if (!(auth_request == rhs.auth_request))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_login_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_login_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_login_pargs {
+ public:
+
+
+  virtual ~Cassandra_login_pargs() throw() {}
+
+  const AuthenticationRequest* auth_request;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_login_result__isset {
+  _Cassandra_login_result__isset() : failure(false), authnx(false), authzx(false) {}
+  bool failure;
+  bool authnx;
+  bool authzx;
+} _Cassandra_login_result__isset;
+
+class Cassandra_login_result {
+ public:
+
+  Cassandra_login_result() {
+  }
+
+  virtual ~Cassandra_login_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  AuthenticationException authnx;
+  AuthorizationException authzx;
+
+  _Cassandra_login_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_authnx(const AuthenticationException& val) {
+    authnx = val;
+  }
+
+  void __set_authzx(const AuthorizationException& val) {
+    authzx = val;
+  }
+
+  bool operator == (const Cassandra_login_result & rhs) const
+  {
+    if (!(authnx == rhs.authnx))
+      return false;
+    if (!(authzx == rhs.authzx))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_login_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_login_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_login_presult__isset {
+  _Cassandra_login_presult__isset() : failure(false), authnx(false), authzx(false) {}
+  bool failure;
+  bool authnx;
+  bool authzx;
+} _Cassandra_login_presult__isset;
+
+class Cassandra_login_presult {
+ public:
+
+
+  virtual ~Cassandra_login_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  AuthenticationException authnx;
+  AuthorizationException authzx;
+
+  _Cassandra_login_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_set_keyspace_args {
+ public:
+
+  Cassandra_set_keyspace_args() : keyspace() {
+  }
+
+  virtual ~Cassandra_set_keyspace_args() throw() {}
+
+  std::string keyspace;
+
+  void __set_keyspace(const std::string& val) {
+    keyspace = val;
+  }
+
+  bool operator == (const Cassandra_set_keyspace_args & rhs) const
+  {
+    if (!(keyspace == rhs.keyspace))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_set_keyspace_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_set_keyspace_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_set_keyspace_pargs {
+ public:
+
+
+  virtual ~Cassandra_set_keyspace_pargs() throw() {}
+
+  const std::string* keyspace;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_set_keyspace_result__isset {
+  _Cassandra_set_keyspace_result__isset() : failure(false), ire(false) {}
+  bool failure;
+  bool ire;
+} _Cassandra_set_keyspace_result__isset;
+
+class Cassandra_set_keyspace_result {
+ public:
+
+  Cassandra_set_keyspace_result() {
+  }
+
+  virtual ~Cassandra_set_keyspace_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_set_keyspace_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_set_keyspace_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_set_keyspace_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_set_keyspace_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_set_keyspace_presult__isset {
+  _Cassandra_set_keyspace_presult__isset() : failure(false), ire(false) {}
+  bool failure;
+  bool ire;
+} _Cassandra_set_keyspace_presult__isset;
+
+class Cassandra_set_keyspace_presult {
+ public:
+
+
+  virtual ~Cassandra_set_keyspace_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_set_keyspace_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_get_args {
+ public:
+
+  Cassandra_get_args() : key(), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_get_args() throw() {}
+
+  std::string key;
+  ColumnPath column_path;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_key(const std::string& val) {
+    key = val;
+  }
+
+  void __set_column_path(const ColumnPath& val) {
+    column_path = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_get_args & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(column_path == rhs.column_path))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_get_pargs {
+ public:
+
+
+  virtual ~Cassandra_get_pargs() throw() {}
+
+  const std::string* key;
+  const ColumnPath* column_path;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_result__isset {
+  _Cassandra_get_result__isset() : success(false), failure(false), ire(false), nfe(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool nfe;
+  bool ue;
+  bool te;
+} _Cassandra_get_result__isset;
+
+class Cassandra_get_result {
+ public:
+
+  Cassandra_get_result() {
+  }
+
+  virtual ~Cassandra_get_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const ColumnOrSuperColumn& success_constref_nonvoid_t;
+  typedef const ColumnOrSuperColumn& success_constref_t;
+  typedef ColumnOrSuperColumn success_nonvoid_t;
+  typedef ColumnOrSuperColumn success_t;
+  ColumnOrSuperColumn success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  NotFoundException nfe;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_result__isset __isset;
+
+  void __set_success(const ColumnOrSuperColumn& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_nfe(const NotFoundException& val) {
+    nfe = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_get_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(nfe == rhs.nfe))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_presult__isset {
+  _Cassandra_get_presult__isset() : success(false), failure(false), ire(false), nfe(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool nfe;
+  bool ue;
+  bool te;
+} _Cassandra_get_presult__isset;
+
+class Cassandra_get_presult {
+ public:
+
+
+  virtual ~Cassandra_get_presult() throw() {}
+
+  ColumnOrSuperColumn* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  NotFoundException nfe;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_get_slice_args {
+ public:
+
+  Cassandra_get_slice_args() : key(), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_get_slice_args() throw() {}
+
+  std::string key;
+  ColumnParent column_parent;
+  SlicePredicate predicate;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_key(const std::string& val) {
+    key = val;
+  }
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_predicate(const SlicePredicate& val) {
+    predicate = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_get_slice_args & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(predicate == rhs.predicate))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_slice_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_slice_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_get_slice_pargs {
+ public:
+
+
+  virtual ~Cassandra_get_slice_pargs() throw() {}
+
+  const std::string* key;
+  const ColumnParent* column_parent;
+  const SlicePredicate* predicate;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_slice_result__isset {
+  _Cassandra_get_slice_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_slice_result__isset;
+
+class Cassandra_get_slice_result {
+ public:
+
+  Cassandra_get_slice_result() {
+  }
+
+  virtual ~Cassandra_get_slice_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::vector<ColumnOrSuperColumn> & success_constref_nonvoid_t;
+  typedef const std::vector<ColumnOrSuperColumn> & success_constref_t;
+  typedef std::vector<ColumnOrSuperColumn>  success_nonvoid_t;
+  typedef std::vector<ColumnOrSuperColumn>  success_t;
+  std::vector<ColumnOrSuperColumn>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_slice_result__isset __isset;
+
+  void __set_success(const std::vector<ColumnOrSuperColumn> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_get_slice_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_slice_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_slice_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_slice_presult__isset {
+  _Cassandra_get_slice_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_slice_presult__isset;
+
+class Cassandra_get_slice_presult {
+ public:
+
+
+  virtual ~Cassandra_get_slice_presult() throw() {}
+
+  std::vector<ColumnOrSuperColumn> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_slice_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_get_count_args {
+ public:
+
+  Cassandra_get_count_args() : key(), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_get_count_args() throw() {}
+
+  std::string key;
+  ColumnParent column_parent;
+  SlicePredicate predicate;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_key(const std::string& val) {
+    key = val;
+  }
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_predicate(const SlicePredicate& val) {
+    predicate = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_get_count_args & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(predicate == rhs.predicate))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_count_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_count_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_get_count_pargs {
+ public:
+
+
+  virtual ~Cassandra_get_count_pargs() throw() {}
+
+  const std::string* key;
+  const ColumnParent* column_parent;
+  const SlicePredicate* predicate;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_count_result__isset {
+  _Cassandra_get_count_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_count_result__isset;
+
+class Cassandra_get_count_result {
+ public:
+
+  Cassandra_get_count_result() : success(0) {
+  }
+
+  virtual ~Cassandra_get_count_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef int32_t success_constref_nonvoid_t;
+  typedef int32_t success_constref_t;
+  typedef int32_t success_nonvoid_t;
+  typedef int32_t success_t;
+  int32_t success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_count_result__isset __isset;
+
+  void __set_success(const int32_t val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_get_count_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_count_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_count_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_count_presult__isset {
+  _Cassandra_get_count_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_count_presult__isset;
+
+class Cassandra_get_count_presult {
+ public:
+
+
+  virtual ~Cassandra_get_count_presult() throw() {}
+
+  int32_t* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_count_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_multiget_slice_args {
+ public:
+
+  Cassandra_multiget_slice_args() : consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_multiget_slice_args() throw() {}
+
+  std::vector<std::string>  keys;
+  ColumnParent column_parent;
+  SlicePredicate predicate;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_keys(const std::vector<std::string> & val) {
+    keys = val;
+  }
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_predicate(const SlicePredicate& val) {
+    predicate = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_multiget_slice_args & rhs) const
+  {
+    if (!(keys == rhs.keys))
+      return false;
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(predicate == rhs.predicate))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_multiget_slice_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_multiget_slice_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_multiget_slice_pargs {
+ public:
+
+
+  virtual ~Cassandra_multiget_slice_pargs() throw() {}
+
+  const std::vector<std::string> * keys;
+  const ColumnParent* column_parent;
+  const SlicePredicate* predicate;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_multiget_slice_result__isset {
+  _Cassandra_multiget_slice_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_multiget_slice_result__isset;
+
+class Cassandra_multiget_slice_result {
+ public:
+
+  Cassandra_multiget_slice_result() {
+  }
+
+  virtual ~Cassandra_multiget_slice_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::map<std::string, std::vector<ColumnOrSuperColumn> > & success_constref_nonvoid_t;
+  typedef const std::map<std::string, std::vector<ColumnOrSuperColumn> > & success_constref_t;
+  typedef std::map<std::string, std::vector<ColumnOrSuperColumn> >  success_nonvoid_t;
+  typedef std::map<std::string, std::vector<ColumnOrSuperColumn> >  success_t;
+  std::map<std::string, std::vector<ColumnOrSuperColumn> >  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_multiget_slice_result__isset __isset;
+
+  void __set_success(const std::map<std::string, std::vector<ColumnOrSuperColumn> > & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_multiget_slice_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_multiget_slice_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_multiget_slice_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_multiget_slice_presult__isset {
+  _Cassandra_multiget_slice_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_multiget_slice_presult__isset;
+
+class Cassandra_multiget_slice_presult {
+ public:
+
+
+  virtual ~Cassandra_multiget_slice_presult() throw() {}
+
+  std::map<std::string, std::vector<ColumnOrSuperColumn> > * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_multiget_slice_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_multiget_count_args {
+ public:
+
+  Cassandra_multiget_count_args() : consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_multiget_count_args() throw() {}
+
+  std::vector<std::string>  keys;
+  ColumnParent column_parent;
+  SlicePredicate predicate;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_keys(const std::vector<std::string> & val) {
+    keys = val;
+  }
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_predicate(const SlicePredicate& val) {
+    predicate = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_multiget_count_args & rhs) const
+  {
+    if (!(keys == rhs.keys))
+      return false;
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(predicate == rhs.predicate))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_multiget_count_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_multiget_count_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_multiget_count_pargs {
+ public:
+
+
+  virtual ~Cassandra_multiget_count_pargs() throw() {}
+
+  const std::vector<std::string> * keys;
+  const ColumnParent* column_parent;
+  const SlicePredicate* predicate;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_multiget_count_result__isset {
+  _Cassandra_multiget_count_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_multiget_count_result__isset;
+
+class Cassandra_multiget_count_result {
+ public:
+
+  Cassandra_multiget_count_result() {
+  }
+
+  virtual ~Cassandra_multiget_count_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::map<std::string, int32_t> & success_constref_nonvoid_t;
+  typedef const std::map<std::string, int32_t> & success_constref_t;
+  typedef std::map<std::string, int32_t>  success_nonvoid_t;
+  typedef std::map<std::string, int32_t>  success_t;
+  std::map<std::string, int32_t>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_multiget_count_result__isset __isset;
+
+  void __set_success(const std::map<std::string, int32_t> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_multiget_count_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_multiget_count_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_multiget_count_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_multiget_count_presult__isset {
+  _Cassandra_multiget_count_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_multiget_count_presult__isset;
+
+class Cassandra_multiget_count_presult {
+ public:
+
+
+  virtual ~Cassandra_multiget_count_presult() throw() {}
+
+  std::map<std::string, int32_t> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_multiget_count_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_get_range_slices_args {
+ public:
+
+  Cassandra_get_range_slices_args() : consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_get_range_slices_args() throw() {}
+
+  ColumnParent column_parent;
+  SlicePredicate predicate;
+  KeyRange range;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_predicate(const SlicePredicate& val) {
+    predicate = val;
+  }
+
+  void __set_range(const KeyRange& val) {
+    range = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_get_range_slices_args & rhs) const
+  {
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(predicate == rhs.predicate))
+      return false;
+    if (!(range == rhs.range))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_range_slices_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_range_slices_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_get_range_slices_pargs {
+ public:
+
+
+  virtual ~Cassandra_get_range_slices_pargs() throw() {}
+
+  const ColumnParent* column_parent;
+  const SlicePredicate* predicate;
+  const KeyRange* range;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_range_slices_result__isset {
+  _Cassandra_get_range_slices_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_range_slices_result__isset;
+
+class Cassandra_get_range_slices_result {
+ public:
+
+  Cassandra_get_range_slices_result() {
+  }
+
+  virtual ~Cassandra_get_range_slices_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::vector<KeySlice> & success_constref_nonvoid_t;
+  typedef const std::vector<KeySlice> & success_constref_t;
+  typedef std::vector<KeySlice>  success_nonvoid_t;
+  typedef std::vector<KeySlice>  success_t;
+  std::vector<KeySlice>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_range_slices_result__isset __isset;
+
+  void __set_success(const std::vector<KeySlice> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_get_range_slices_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_range_slices_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_range_slices_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_range_slices_presult__isset {
+  _Cassandra_get_range_slices_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_range_slices_presult__isset;
+
+class Cassandra_get_range_slices_presult {
+ public:
+
+
+  virtual ~Cassandra_get_range_slices_presult() throw() {}
+
+  std::vector<KeySlice> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_range_slices_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_get_paged_slice_args {
+ public:
+
+  Cassandra_get_paged_slice_args() : column_family(), start_column(), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_get_paged_slice_args() throw() {}
+
+  std::string column_family;
+  KeyRange range;
+  std::string start_column;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_column_family(const std::string& val) {
+    column_family = val;
+  }
+
+  void __set_range(const KeyRange& val) {
+    range = val;
+  }
+
+  void __set_start_column(const std::string& val) {
+    start_column = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_get_paged_slice_args & rhs) const
+  {
+    if (!(column_family == rhs.column_family))
+      return false;
+    if (!(range == rhs.range))
+      return false;
+    if (!(start_column == rhs.start_column))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_paged_slice_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_paged_slice_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_get_paged_slice_pargs {
+ public:
+
+
+  virtual ~Cassandra_get_paged_slice_pargs() throw() {}
+
+  const std::string* column_family;
+  const KeyRange* range;
+  const std::string* start_column;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_paged_slice_result__isset {
+  _Cassandra_get_paged_slice_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_paged_slice_result__isset;
+
+class Cassandra_get_paged_slice_result {
+ public:
+
+  Cassandra_get_paged_slice_result() {
+  }
+
+  virtual ~Cassandra_get_paged_slice_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::vector<KeySlice> & success_constref_nonvoid_t;
+  typedef const std::vector<KeySlice> & success_constref_t;
+  typedef std::vector<KeySlice>  success_nonvoid_t;
+  typedef std::vector<KeySlice>  success_t;
+  std::vector<KeySlice>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_paged_slice_result__isset __isset;
+
+  void __set_success(const std::vector<KeySlice> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_get_paged_slice_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_paged_slice_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_paged_slice_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_paged_slice_presult__isset {
+  _Cassandra_get_paged_slice_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_paged_slice_presult__isset;
+
+class Cassandra_get_paged_slice_presult {
+ public:
+
+
+  virtual ~Cassandra_get_paged_slice_presult() throw() {}
+
+  std::vector<KeySlice> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_paged_slice_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_get_indexed_slices_args {
+ public:
+
+  Cassandra_get_indexed_slices_args() : consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_get_indexed_slices_args() throw() {}
+
+  ColumnParent column_parent;
+  IndexClause index_clause;
+  SlicePredicate column_predicate;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_index_clause(const IndexClause& val) {
+    index_clause = val;
+  }
+
+  void __set_column_predicate(const SlicePredicate& val) {
+    column_predicate = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_get_indexed_slices_args & rhs) const
+  {
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(index_clause == rhs.index_clause))
+      return false;
+    if (!(column_predicate == rhs.column_predicate))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_indexed_slices_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_indexed_slices_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_get_indexed_slices_pargs {
+ public:
+
+
+  virtual ~Cassandra_get_indexed_slices_pargs() throw() {}
+
+  const ColumnParent* column_parent;
+  const IndexClause* index_clause;
+  const SlicePredicate* column_predicate;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_indexed_slices_result__isset {
+  _Cassandra_get_indexed_slices_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_indexed_slices_result__isset;
+
+class Cassandra_get_indexed_slices_result {
+ public:
+
+  Cassandra_get_indexed_slices_result() {
+  }
+
+  virtual ~Cassandra_get_indexed_slices_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::vector<KeySlice> & success_constref_nonvoid_t;
+  typedef const std::vector<KeySlice> & success_constref_t;
+  typedef std::vector<KeySlice>  success_nonvoid_t;
+  typedef std::vector<KeySlice>  success_t;
+  std::vector<KeySlice>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_indexed_slices_result__isset __isset;
+
+  void __set_success(const std::vector<KeySlice> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_get_indexed_slices_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_get_indexed_slices_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_get_indexed_slices_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_get_indexed_slices_presult__isset {
+  _Cassandra_get_indexed_slices_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_get_indexed_slices_presult__isset;
+
+class Cassandra_get_indexed_slices_presult {
+ public:
+
+
+  virtual ~Cassandra_get_indexed_slices_presult() throw() {}
+
+  std::vector<KeySlice> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_get_indexed_slices_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_insert_args {
+ public:
+
+  Cassandra_insert_args() : key(), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_insert_args() throw() {}
+
+  std::string key;
+  ColumnParent column_parent;
+  Column column;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_key(const std::string& val) {
+    key = val;
+  }
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_column(const Column& val) {
+    column = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_insert_args & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(column == rhs.column))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_insert_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_insert_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_insert_pargs {
+ public:
+
+
+  virtual ~Cassandra_insert_pargs() throw() {}
+
+  const std::string* key;
+  const ColumnParent* column_parent;
+  const Column* column;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_insert_result__isset {
+  _Cassandra_insert_result__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_insert_result__isset;
+
+class Cassandra_insert_result {
+ public:
+
+  Cassandra_insert_result() {
+  }
+
+  virtual ~Cassandra_insert_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_insert_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_insert_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_insert_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_insert_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_insert_presult__isset {
+  _Cassandra_insert_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_insert_presult__isset;
+
+class Cassandra_insert_presult {
+ public:
+
+
+  virtual ~Cassandra_insert_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_insert_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_add_args {
+ public:
+
+  Cassandra_add_args() : key(), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_add_args() throw() {}
+
+  std::string key;
+  ColumnParent column_parent;
+  CounterColumn column;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_key(const std::string& val) {
+    key = val;
+  }
+
+  void __set_column_parent(const ColumnParent& val) {
+    column_parent = val;
+  }
+
+  void __set_column(const CounterColumn& val) {
+    column = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_add_args & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(column_parent == rhs.column_parent))
+      return false;
+    if (!(column == rhs.column))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_add_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_add_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_add_pargs {
+ public:
+
+
+  virtual ~Cassandra_add_pargs() throw() {}
+
+  const std::string* key;
+  const ColumnParent* column_parent;
+  const CounterColumn* column;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_add_result__isset {
+  _Cassandra_add_result__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_add_result__isset;
+
+class Cassandra_add_result {
+ public:
+
+  Cassandra_add_result() {
+  }
+
+  virtual ~Cassandra_add_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_add_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_add_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_add_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_add_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_add_presult__isset {
+  _Cassandra_add_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_add_presult__isset;
+
+class Cassandra_add_presult {
+ public:
+
+
+  virtual ~Cassandra_add_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_add_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Cassandra_remove_args__isset {
+  _Cassandra_remove_args__isset() : consistency_level(true) {}
+  bool consistency_level;
+} _Cassandra_remove_args__isset;
+
+class Cassandra_remove_args {
+ public:
+
+  Cassandra_remove_args() : key(), timestamp(0), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_remove_args() throw() {}
+
+  std::string key;
+  ColumnPath column_path;
+  int64_t timestamp;
+  ConsistencyLevel::type consistency_level;
+
+  _Cassandra_remove_args__isset __isset;
+
+  void __set_key(const std::string& val) {
+    key = val;
+  }
+
+  void __set_column_path(const ColumnPath& val) {
+    column_path = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_remove_args & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(column_path == rhs.column_path))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_remove_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_remove_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_remove_pargs {
+ public:
+
+
+  virtual ~Cassandra_remove_pargs() throw() {}
+
+  const std::string* key;
+  const ColumnPath* column_path;
+  const int64_t* timestamp;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_remove_result__isset {
+  _Cassandra_remove_result__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_remove_result__isset;
+
+class Cassandra_remove_result {
+ public:
+
+  Cassandra_remove_result() {
+  }
+
+  virtual ~Cassandra_remove_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_remove_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_remove_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_remove_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_remove_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_remove_presult__isset {
+  _Cassandra_remove_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_remove_presult__isset;
+
+class Cassandra_remove_presult {
+ public:
+
+
+  virtual ~Cassandra_remove_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_remove_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_remove_counter_args {
+ public:
+
+  Cassandra_remove_counter_args() : key(), consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_remove_counter_args() throw() {}
+
+  std::string key;
+  ColumnPath path;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_key(const std::string& val) {
+    key = val;
+  }
+
+  void __set_path(const ColumnPath& val) {
+    path = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_remove_counter_args & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(path == rhs.path))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_remove_counter_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_remove_counter_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_remove_counter_pargs {
+ public:
+
+
+  virtual ~Cassandra_remove_counter_pargs() throw() {}
+
+  const std::string* key;
+  const ColumnPath* path;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_remove_counter_result__isset {
+  _Cassandra_remove_counter_result__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_remove_counter_result__isset;
+
+class Cassandra_remove_counter_result {
+ public:
+
+  Cassandra_remove_counter_result() {
+  }
+
+  virtual ~Cassandra_remove_counter_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_remove_counter_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_remove_counter_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_remove_counter_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_remove_counter_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_remove_counter_presult__isset {
+  _Cassandra_remove_counter_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_remove_counter_presult__isset;
+
+class Cassandra_remove_counter_presult {
+ public:
+
+
+  virtual ~Cassandra_remove_counter_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_remove_counter_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_batch_mutate_args {
+ public:
+
+  Cassandra_batch_mutate_args() : consistency_level((ConsistencyLevel::type)1) {
+    consistency_level = (ConsistencyLevel::type)1;
+
+  }
+
+  virtual ~Cassandra_batch_mutate_args() throw() {}
+
+  std::map<std::string, std::map<std::string, std::vector<Mutation> > >  mutation_map;
+  ConsistencyLevel::type consistency_level;
+
+  void __set_mutation_map(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & val) {
+    mutation_map = val;
+  }
+
+  void __set_consistency_level(const ConsistencyLevel::type val) {
+    consistency_level = val;
+  }
+
+  bool operator == (const Cassandra_batch_mutate_args & rhs) const
+  {
+    if (!(mutation_map == rhs.mutation_map))
+      return false;
+    if (!(consistency_level == rhs.consistency_level))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_batch_mutate_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_batch_mutate_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_batch_mutate_pargs {
+ public:
+
+
+  virtual ~Cassandra_batch_mutate_pargs() throw() {}
+
+  const std::map<std::string, std::map<std::string, std::vector<Mutation> > > * mutation_map;
+  const ConsistencyLevel::type* consistency_level;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_batch_mutate_result__isset {
+  _Cassandra_batch_mutate_result__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_batch_mutate_result__isset;
+
+class Cassandra_batch_mutate_result {
+ public:
+
+  Cassandra_batch_mutate_result() {
+  }
+
+  virtual ~Cassandra_batch_mutate_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_batch_mutate_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_batch_mutate_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_batch_mutate_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_batch_mutate_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_batch_mutate_presult__isset {
+  _Cassandra_batch_mutate_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_batch_mutate_presult__isset;
+
+class Cassandra_batch_mutate_presult {
+ public:
+
+
+  virtual ~Cassandra_batch_mutate_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_batch_mutate_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_truncate_args {
+ public:
+
+  Cassandra_truncate_args() : cfname() {
+  }
+
+  virtual ~Cassandra_truncate_args() throw() {}
+
+  std::string cfname;
+
+  void __set_cfname(const std::string& val) {
+    cfname = val;
+  }
+
+  bool operator == (const Cassandra_truncate_args & rhs) const
+  {
+    if (!(cfname == rhs.cfname))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_truncate_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_truncate_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_truncate_pargs {
+ public:
+
+
+  virtual ~Cassandra_truncate_pargs() throw() {}
+
+  const std::string* cfname;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_truncate_result__isset {
+  _Cassandra_truncate_result__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_truncate_result__isset;
+
+class Cassandra_truncate_result {
+ public:
+
+  Cassandra_truncate_result() {
+  }
+
+  virtual ~Cassandra_truncate_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_truncate_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  bool operator == (const Cassandra_truncate_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_truncate_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_truncate_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_truncate_presult__isset {
+  _Cassandra_truncate_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+} _Cassandra_truncate_presult__isset;
+
+class Cassandra_truncate_presult {
+ public:
+
+
+  virtual ~Cassandra_truncate_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+
+  _Cassandra_truncate_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_schema_versions_args {
+ public:
+
+  Cassandra_describe_schema_versions_args() {
+  }
+
+  virtual ~Cassandra_describe_schema_versions_args() throw() {}
+
+
+  bool operator == (const Cassandra_describe_schema_versions_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Cassandra_describe_schema_versions_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_schema_versions_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_schema_versions_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_schema_versions_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_schema_versions_result__isset {
+  _Cassandra_describe_schema_versions_result__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_schema_versions_result__isset;
+
+class Cassandra_describe_schema_versions_result {
+ public:
+
+  Cassandra_describe_schema_versions_result() {
+  }
+
+  virtual ~Cassandra_describe_schema_versions_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::map<std::string, std::vector<std::string> > & success_constref_nonvoid_t;
+  typedef const std::map<std::string, std::vector<std::string> > & success_constref_t;
+  typedef std::map<std::string, std::vector<std::string> >  success_nonvoid_t;
+  typedef std::map<std::string, std::vector<std::string> >  success_t;
+  std::map<std::string, std::vector<std::string> >  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_schema_versions_result__isset __isset;
+
+  void __set_success(const std::map<std::string, std::vector<std::string> > & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_describe_schema_versions_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_schema_versions_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_schema_versions_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_schema_versions_presult__isset {
+  _Cassandra_describe_schema_versions_presult__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_schema_versions_presult__isset;
+
+class Cassandra_describe_schema_versions_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_schema_versions_presult() throw() {}
+
+  std::map<std::string, std::vector<std::string> > * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_schema_versions_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_keyspaces_args {
+ public:
+
+  Cassandra_describe_keyspaces_args() {
+  }
+
+  virtual ~Cassandra_describe_keyspaces_args() throw() {}
+
+
+  bool operator == (const Cassandra_describe_keyspaces_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Cassandra_describe_keyspaces_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_keyspaces_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_keyspaces_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_keyspaces_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_keyspaces_result__isset {
+  _Cassandra_describe_keyspaces_result__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_keyspaces_result__isset;
+
+class Cassandra_describe_keyspaces_result {
+ public:
+
+  Cassandra_describe_keyspaces_result() {
+  }
+
+  virtual ~Cassandra_describe_keyspaces_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::vector<KsDef> & success_constref_nonvoid_t;
+  typedef const std::vector<KsDef> & success_constref_t;
+  typedef std::vector<KsDef>  success_nonvoid_t;
+  typedef std::vector<KsDef>  success_t;
+  std::vector<KsDef>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_keyspaces_result__isset __isset;
+
+  void __set_success(const std::vector<KsDef> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_describe_keyspaces_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_keyspaces_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_keyspaces_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_keyspaces_presult__isset {
+  _Cassandra_describe_keyspaces_presult__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_keyspaces_presult__isset;
+
+class Cassandra_describe_keyspaces_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_keyspaces_presult() throw() {}
+
+  std::vector<KsDef> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_keyspaces_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_cluster_name_args {
+ public:
+
+  Cassandra_describe_cluster_name_args() {
+  }
+
+  virtual ~Cassandra_describe_cluster_name_args() throw() {}
+
+
+  bool operator == (const Cassandra_describe_cluster_name_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Cassandra_describe_cluster_name_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_cluster_name_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_cluster_name_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_cluster_name_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_cluster_name_result__isset {
+  _Cassandra_describe_cluster_name_result__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_cluster_name_result__isset;
+
+class Cassandra_describe_cluster_name_result {
+ public:
+
+  Cassandra_describe_cluster_name_result() : success() {
+  }
+
+  virtual ~Cassandra_describe_cluster_name_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+
+  _Cassandra_describe_cluster_name_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  bool operator == (const Cassandra_describe_cluster_name_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_cluster_name_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_cluster_name_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_cluster_name_presult__isset {
+  _Cassandra_describe_cluster_name_presult__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_cluster_name_presult__isset;
+
+class Cassandra_describe_cluster_name_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_cluster_name_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+
+  _Cassandra_describe_cluster_name_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_version_args {
+ public:
+
+  Cassandra_describe_version_args() {
+  }
+
+  virtual ~Cassandra_describe_version_args() throw() {}
+
+
+  bool operator == (const Cassandra_describe_version_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Cassandra_describe_version_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_version_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_version_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_version_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_version_result__isset {
+  _Cassandra_describe_version_result__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_version_result__isset;
+
+class Cassandra_describe_version_result {
+ public:
+
+  Cassandra_describe_version_result() : success() {
+  }
+
+  virtual ~Cassandra_describe_version_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+
+  _Cassandra_describe_version_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  bool operator == (const Cassandra_describe_version_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_version_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_version_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_version_presult__isset {
+  _Cassandra_describe_version_presult__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_version_presult__isset;
+
+class Cassandra_describe_version_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_version_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+
+  _Cassandra_describe_version_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_ring_args {
+ public:
+
+  Cassandra_describe_ring_args() : keyspace() {
+  }
+
+  virtual ~Cassandra_describe_ring_args() throw() {}
+
+  std::string keyspace;
+
+  void __set_keyspace(const std::string& val) {
+    keyspace = val;
+  }
+
+  bool operator == (const Cassandra_describe_ring_args & rhs) const
+  {
+    if (!(keyspace == rhs.keyspace))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_ring_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_ring_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_ring_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_ring_pargs() throw() {}
+
+  const std::string* keyspace;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_ring_result__isset {
+  _Cassandra_describe_ring_result__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_ring_result__isset;
+
+class Cassandra_describe_ring_result {
+ public:
+
+  Cassandra_describe_ring_result() {
+  }
+
+  virtual ~Cassandra_describe_ring_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::vector<TokenRange> & success_constref_nonvoid_t;
+  typedef const std::vector<TokenRange> & success_constref_t;
+  typedef std::vector<TokenRange>  success_nonvoid_t;
+  typedef std::vector<TokenRange>  success_t;
+  std::vector<TokenRange>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_ring_result__isset __isset;
+
+  void __set_success(const std::vector<TokenRange> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_describe_ring_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_ring_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_ring_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_ring_presult__isset {
+  _Cassandra_describe_ring_presult__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_ring_presult__isset;
+
+class Cassandra_describe_ring_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_ring_presult() throw() {}
+
+  std::vector<TokenRange> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_ring_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_token_map_args {
+ public:
+
+  Cassandra_describe_token_map_args() {
+  }
+
+  virtual ~Cassandra_describe_token_map_args() throw() {}
+
+
+  bool operator == (const Cassandra_describe_token_map_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Cassandra_describe_token_map_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_token_map_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_token_map_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_token_map_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_token_map_result__isset {
+  _Cassandra_describe_token_map_result__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_token_map_result__isset;
+
+class Cassandra_describe_token_map_result {
+ public:
+
+  Cassandra_describe_token_map_result() {
+  }
+
+  virtual ~Cassandra_describe_token_map_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::map<std::string, std::string> & success_constref_nonvoid_t;
+  typedef const std::map<std::string, std::string> & success_constref_t;
+  typedef std::map<std::string, std::string>  success_nonvoid_t;
+  typedef std::map<std::string, std::string>  success_t;
+  std::map<std::string, std::string>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_token_map_result__isset __isset;
+
+  void __set_success(const std::map<std::string, std::string> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_describe_token_map_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_token_map_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_token_map_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_token_map_presult__isset {
+  _Cassandra_describe_token_map_presult__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_token_map_presult__isset;
+
+class Cassandra_describe_token_map_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_token_map_presult() throw() {}
+
+  std::map<std::string, std::string> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_token_map_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_partitioner_args {
+ public:
+
+  Cassandra_describe_partitioner_args() {
+  }
+
+  virtual ~Cassandra_describe_partitioner_args() throw() {}
+
+
+  bool operator == (const Cassandra_describe_partitioner_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Cassandra_describe_partitioner_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_partitioner_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_partitioner_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_partitioner_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_partitioner_result__isset {
+  _Cassandra_describe_partitioner_result__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_partitioner_result__isset;
+
+class Cassandra_describe_partitioner_result {
+ public:
+
+  Cassandra_describe_partitioner_result() : success() {
+  }
+
+  virtual ~Cassandra_describe_partitioner_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+
+  _Cassandra_describe_partitioner_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  bool operator == (const Cassandra_describe_partitioner_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_partitioner_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_partitioner_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_partitioner_presult__isset {
+  _Cassandra_describe_partitioner_presult__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_partitioner_presult__isset;
+
+class Cassandra_describe_partitioner_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_partitioner_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+
+  _Cassandra_describe_partitioner_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_snitch_args {
+ public:
+
+  Cassandra_describe_snitch_args() {
+  }
+
+  virtual ~Cassandra_describe_snitch_args() throw() {}
+
+
+  bool operator == (const Cassandra_describe_snitch_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Cassandra_describe_snitch_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_snitch_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_snitch_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_snitch_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_snitch_result__isset {
+  _Cassandra_describe_snitch_result__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_snitch_result__isset;
+
+class Cassandra_describe_snitch_result {
+ public:
+
+  Cassandra_describe_snitch_result() : success() {
+  }
+
+  virtual ~Cassandra_describe_snitch_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+
+  _Cassandra_describe_snitch_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  bool operator == (const Cassandra_describe_snitch_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_snitch_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_snitch_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_snitch_presult__isset {
+  _Cassandra_describe_snitch_presult__isset() : success(false), failure(false) {}
+  bool success;
+  bool failure;
+} _Cassandra_describe_snitch_presult__isset;
+
+class Cassandra_describe_snitch_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_snitch_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+
+  _Cassandra_describe_snitch_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_keyspace_args {
+ public:
+
+  Cassandra_describe_keyspace_args() : keyspace() {
+  }
+
+  virtual ~Cassandra_describe_keyspace_args() throw() {}
+
+  std::string keyspace;
+
+  void __set_keyspace(const std::string& val) {
+    keyspace = val;
+  }
+
+  bool operator == (const Cassandra_describe_keyspace_args & rhs) const
+  {
+    if (!(keyspace == rhs.keyspace))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_keyspace_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_keyspace_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_keyspace_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_keyspace_pargs() throw() {}
+
+  const std::string* keyspace;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_keyspace_result__isset {
+  _Cassandra_describe_keyspace_result__isset() : success(false), failure(false), nfe(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool nfe;
+  bool ire;
+} _Cassandra_describe_keyspace_result__isset;
+
+class Cassandra_describe_keyspace_result {
+ public:
+
+  Cassandra_describe_keyspace_result() {
+  }
+
+  virtual ~Cassandra_describe_keyspace_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const KsDef& success_constref_nonvoid_t;
+  typedef const KsDef& success_constref_t;
+  typedef KsDef success_nonvoid_t;
+  typedef KsDef success_t;
+  KsDef success;
+  apache::thrift::TApplicationException failure;
+  NotFoundException nfe;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_keyspace_result__isset __isset;
+
+  void __set_success(const KsDef& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_nfe(const NotFoundException& val) {
+    nfe = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_describe_keyspace_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(nfe == rhs.nfe))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_keyspace_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_keyspace_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_keyspace_presult__isset {
+  _Cassandra_describe_keyspace_presult__isset() : success(false), failure(false), nfe(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool nfe;
+  bool ire;
+} _Cassandra_describe_keyspace_presult__isset;
+
+class Cassandra_describe_keyspace_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_keyspace_presult() throw() {}
+
+  KsDef* success;
+  apache::thrift::TApplicationException* failure;
+  NotFoundException nfe;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_keyspace_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_describe_splits_args {
+ public:
+
+  Cassandra_describe_splits_args() : cfName(), start_token(), end_token(), keys_per_split(0) {
+  }
+
+  virtual ~Cassandra_describe_splits_args() throw() {}
+
+  std::string cfName;
+  std::string start_token;
+  std::string end_token;
+  int32_t keys_per_split;
+
+  void __set_cfName(const std::string& val) {
+    cfName = val;
+  }
+
+  void __set_start_token(const std::string& val) {
+    start_token = val;
+  }
+
+  void __set_end_token(const std::string& val) {
+    end_token = val;
+  }
+
+  void __set_keys_per_split(const int32_t val) {
+    keys_per_split = val;
+  }
+
+  bool operator == (const Cassandra_describe_splits_args & rhs) const
+  {
+    if (!(cfName == rhs.cfName))
+      return false;
+    if (!(start_token == rhs.start_token))
+      return false;
+    if (!(end_token == rhs.end_token))
+      return false;
+    if (!(keys_per_split == rhs.keys_per_split))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_splits_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_splits_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_describe_splits_pargs {
+ public:
+
+
+  virtual ~Cassandra_describe_splits_pargs() throw() {}
+
+  const std::string* cfName;
+  const std::string* start_token;
+  const std::string* end_token;
+  const int32_t* keys_per_split;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_splits_result__isset {
+  _Cassandra_describe_splits_result__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_splits_result__isset;
+
+class Cassandra_describe_splits_result {
+ public:
+
+  Cassandra_describe_splits_result() {
+  }
+
+  virtual ~Cassandra_describe_splits_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::vector<std::string> & success_constref_nonvoid_t;
+  typedef const std::vector<std::string> & success_constref_t;
+  typedef std::vector<std::string>  success_nonvoid_t;
+  typedef std::vector<std::string>  success_t;
+  std::vector<std::string>  success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_splits_result__isset __isset;
+
+  void __set_success(const std::vector<std::string> & val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_describe_splits_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_describe_splits_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_describe_splits_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_describe_splits_presult__isset {
+  _Cassandra_describe_splits_presult__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_describe_splits_presult__isset;
+
+class Cassandra_describe_splits_presult {
+ public:
+
+
+  virtual ~Cassandra_describe_splits_presult() throw() {}
+
+  std::vector<std::string> * success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_describe_splits_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_system_add_column_family_args {
+ public:
+
+  Cassandra_system_add_column_family_args() {
+  }
+
+  virtual ~Cassandra_system_add_column_family_args() throw() {}
+
+  CfDef cf_def;
+
+  void __set_cf_def(const CfDef& val) {
+    cf_def = val;
+  }
+
+  bool operator == (const Cassandra_system_add_column_family_args & rhs) const
+  {
+    if (!(cf_def == rhs.cf_def))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_add_column_family_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_add_column_family_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_system_add_column_family_pargs {
+ public:
+
+
+  virtual ~Cassandra_system_add_column_family_pargs() throw() {}
+
+  const CfDef* cf_def;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_add_column_family_result__isset {
+  _Cassandra_system_add_column_family_result__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_add_column_family_result__isset;
+
+class Cassandra_system_add_column_family_result {
+ public:
+
+  Cassandra_system_add_column_family_result() : success() {
+  }
+
+  virtual ~Cassandra_system_add_column_family_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_add_column_family_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_system_add_column_family_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_add_column_family_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_add_column_family_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_add_column_family_presult__isset {
+  _Cassandra_system_add_column_family_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_add_column_family_presult__isset;
+
+class Cassandra_system_add_column_family_presult {
+ public:
+
+
+  virtual ~Cassandra_system_add_column_family_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_add_column_family_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_system_drop_column_family_args {
+ public:
+
+  Cassandra_system_drop_column_family_args() : column_family() {
+  }
+
+  virtual ~Cassandra_system_drop_column_family_args() throw() {}
+
+  std::string column_family;
+
+  void __set_column_family(const std::string& val) {
+    column_family = val;
+  }
+
+  bool operator == (const Cassandra_system_drop_column_family_args & rhs) const
+  {
+    if (!(column_family == rhs.column_family))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_drop_column_family_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_drop_column_family_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_system_drop_column_family_pargs {
+ public:
+
+
+  virtual ~Cassandra_system_drop_column_family_pargs() throw() {}
+
+  const std::string* column_family;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_drop_column_family_result__isset {
+  _Cassandra_system_drop_column_family_result__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_drop_column_family_result__isset;
+
+class Cassandra_system_drop_column_family_result {
+ public:
+
+  Cassandra_system_drop_column_family_result() : success() {
+  }
+
+  virtual ~Cassandra_system_drop_column_family_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_drop_column_family_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_system_drop_column_family_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_drop_column_family_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_drop_column_family_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_drop_column_family_presult__isset {
+  _Cassandra_system_drop_column_family_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_drop_column_family_presult__isset;
+
+class Cassandra_system_drop_column_family_presult {
+ public:
+
+
+  virtual ~Cassandra_system_drop_column_family_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_drop_column_family_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_system_add_keyspace_args {
+ public:
+
+  Cassandra_system_add_keyspace_args() {
+  }
+
+  virtual ~Cassandra_system_add_keyspace_args() throw() {}
+
+  KsDef ks_def;
+
+  void __set_ks_def(const KsDef& val) {
+    ks_def = val;
+  }
+
+  bool operator == (const Cassandra_system_add_keyspace_args & rhs) const
+  {
+    if (!(ks_def == rhs.ks_def))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_add_keyspace_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_add_keyspace_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_system_add_keyspace_pargs {
+ public:
+
+
+  virtual ~Cassandra_system_add_keyspace_pargs() throw() {}
+
+  const KsDef* ks_def;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_add_keyspace_result__isset {
+  _Cassandra_system_add_keyspace_result__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_add_keyspace_result__isset;
+
+class Cassandra_system_add_keyspace_result {
+ public:
+
+  Cassandra_system_add_keyspace_result() : success() {
+  }
+
+  virtual ~Cassandra_system_add_keyspace_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_add_keyspace_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_system_add_keyspace_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_add_keyspace_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_add_keyspace_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_add_keyspace_presult__isset {
+  _Cassandra_system_add_keyspace_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_add_keyspace_presult__isset;
+
+class Cassandra_system_add_keyspace_presult {
+ public:
+
+
+  virtual ~Cassandra_system_add_keyspace_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_add_keyspace_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_system_drop_keyspace_args {
+ public:
+
+  Cassandra_system_drop_keyspace_args() : keyspace() {
+  }
+
+  virtual ~Cassandra_system_drop_keyspace_args() throw() {}
+
+  std::string keyspace;
+
+  void __set_keyspace(const std::string& val) {
+    keyspace = val;
+  }
+
+  bool operator == (const Cassandra_system_drop_keyspace_args & rhs) const
+  {
+    if (!(keyspace == rhs.keyspace))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_drop_keyspace_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_drop_keyspace_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_system_drop_keyspace_pargs {
+ public:
+
+
+  virtual ~Cassandra_system_drop_keyspace_pargs() throw() {}
+
+  const std::string* keyspace;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_drop_keyspace_result__isset {
+  _Cassandra_system_drop_keyspace_result__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_drop_keyspace_result__isset;
+
+class Cassandra_system_drop_keyspace_result {
+ public:
+
+  Cassandra_system_drop_keyspace_result() : success() {
+  }
+
+  virtual ~Cassandra_system_drop_keyspace_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_drop_keyspace_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_system_drop_keyspace_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_drop_keyspace_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_drop_keyspace_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_drop_keyspace_presult__isset {
+  _Cassandra_system_drop_keyspace_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_drop_keyspace_presult__isset;
+
+class Cassandra_system_drop_keyspace_presult {
+ public:
+
+
+  virtual ~Cassandra_system_drop_keyspace_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_drop_keyspace_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_system_update_keyspace_args {
+ public:
+
+  Cassandra_system_update_keyspace_args() {
+  }
+
+  virtual ~Cassandra_system_update_keyspace_args() throw() {}
+
+  KsDef ks_def;
+
+  void __set_ks_def(const KsDef& val) {
+    ks_def = val;
+  }
+
+  bool operator == (const Cassandra_system_update_keyspace_args & rhs) const
+  {
+    if (!(ks_def == rhs.ks_def))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_update_keyspace_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_update_keyspace_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_system_update_keyspace_pargs {
+ public:
+
+
+  virtual ~Cassandra_system_update_keyspace_pargs() throw() {}
+
+  const KsDef* ks_def;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_update_keyspace_result__isset {
+  _Cassandra_system_update_keyspace_result__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_update_keyspace_result__isset;
+
+class Cassandra_system_update_keyspace_result {
+ public:
+
+  Cassandra_system_update_keyspace_result() : success() {
+  }
+
+  virtual ~Cassandra_system_update_keyspace_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_update_keyspace_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_system_update_keyspace_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_update_keyspace_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_update_keyspace_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_update_keyspace_presult__isset {
+  _Cassandra_system_update_keyspace_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_update_keyspace_presult__isset;
+
+class Cassandra_system_update_keyspace_presult {
+ public:
+
+
+  virtual ~Cassandra_system_update_keyspace_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_update_keyspace_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_system_update_column_family_args {
+ public:
+
+  Cassandra_system_update_column_family_args() {
+  }
+
+  virtual ~Cassandra_system_update_column_family_args() throw() {}
+
+  CfDef cf_def;
+
+  void __set_cf_def(const CfDef& val) {
+    cf_def = val;
+  }
+
+  bool operator == (const Cassandra_system_update_column_family_args & rhs) const
+  {
+    if (!(cf_def == rhs.cf_def))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_update_column_family_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_update_column_family_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_system_update_column_family_pargs {
+ public:
+
+
+  virtual ~Cassandra_system_update_column_family_pargs() throw() {}
+
+  const CfDef* cf_def;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_update_column_family_result__isset {
+  _Cassandra_system_update_column_family_result__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_update_column_family_result__isset;
+
+class Cassandra_system_update_column_family_result {
+ public:
+
+  Cassandra_system_update_column_family_result() : success() {
+  }
+
+  virtual ~Cassandra_system_update_column_family_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const std::string& success_constref_nonvoid_t;
+  typedef const std::string& success_constref_t;
+  typedef std::string success_nonvoid_t;
+  typedef std::string success_t;
+  std::string success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_update_column_family_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_system_update_column_family_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_system_update_column_family_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_system_update_column_family_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_system_update_column_family_presult__isset {
+  _Cassandra_system_update_column_family_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool sde;
+} _Cassandra_system_update_column_family_presult__isset;
+
+class Cassandra_system_update_column_family_presult {
+ public:
+
+
+  virtual ~Cassandra_system_update_column_family_presult() throw() {}
+
+  std::string* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  SchemaDisagreementException sde;
+
+  _Cassandra_system_update_column_family_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_execute_cql_query_args {
+ public:
+
+  Cassandra_execute_cql_query_args() : query(), compression((Compression::type)0) {
+  }
+
+  virtual ~Cassandra_execute_cql_query_args() throw() {}
+
+  std::string query;
+  Compression::type compression;
+
+  void __set_query(const std::string& val) {
+    query = val;
+  }
+
+  void __set_compression(const Compression::type val) {
+    compression = val;
+  }
+
+  bool operator == (const Cassandra_execute_cql_query_args & rhs) const
+  {
+    if (!(query == rhs.query))
+      return false;
+    if (!(compression == rhs.compression))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_execute_cql_query_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_execute_cql_query_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_execute_cql_query_pargs {
+ public:
+
+
+  virtual ~Cassandra_execute_cql_query_pargs() throw() {}
+
+  const std::string* query;
+  const Compression::type* compression;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_execute_cql_query_result__isset {
+  _Cassandra_execute_cql_query_result__isset() : success(false), failure(false), ire(false), ue(false), te(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+  bool sde;
+} _Cassandra_execute_cql_query_result__isset;
+
+class Cassandra_execute_cql_query_result {
+ public:
+
+  Cassandra_execute_cql_query_result() {
+  }
+
+  virtual ~Cassandra_execute_cql_query_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const CqlResult& success_constref_nonvoid_t;
+  typedef const CqlResult& success_constref_t;
+  typedef CqlResult success_nonvoid_t;
+  typedef CqlResult success_t;
+  CqlResult success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+  SchemaDisagreementException sde;
+
+  _Cassandra_execute_cql_query_result__isset __isset;
+
+  void __set_success(const CqlResult& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_execute_cql_query_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_execute_cql_query_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_execute_cql_query_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_execute_cql_query_presult__isset {
+  _Cassandra_execute_cql_query_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+  bool sde;
+} _Cassandra_execute_cql_query_presult__isset;
+
+class Cassandra_execute_cql_query_presult {
+ public:
+
+
+  virtual ~Cassandra_execute_cql_query_presult() throw() {}
+
+  CqlResult* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+  SchemaDisagreementException sde;
+
+  _Cassandra_execute_cql_query_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_prepare_cql_query_args {
+ public:
+
+  Cassandra_prepare_cql_query_args() : query(), compression((Compression::type)0) {
+  }
+
+  virtual ~Cassandra_prepare_cql_query_args() throw() {}
+
+  std::string query;
+  Compression::type compression;
+
+  void __set_query(const std::string& val) {
+    query = val;
+  }
+
+  void __set_compression(const Compression::type val) {
+    compression = val;
+  }
+
+  bool operator == (const Cassandra_prepare_cql_query_args & rhs) const
+  {
+    if (!(query == rhs.query))
+      return false;
+    if (!(compression == rhs.compression))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_prepare_cql_query_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_prepare_cql_query_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_prepare_cql_query_pargs {
+ public:
+
+
+  virtual ~Cassandra_prepare_cql_query_pargs() throw() {}
+
+  const std::string* query;
+  const Compression::type* compression;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_prepare_cql_query_result__isset {
+  _Cassandra_prepare_cql_query_result__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_prepare_cql_query_result__isset;
+
+class Cassandra_prepare_cql_query_result {
+ public:
+
+  Cassandra_prepare_cql_query_result() {
+  }
+
+  virtual ~Cassandra_prepare_cql_query_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const CqlPreparedResult& success_constref_nonvoid_t;
+  typedef const CqlPreparedResult& success_constref_t;
+  typedef CqlPreparedResult success_nonvoid_t;
+  typedef CqlPreparedResult success_t;
+  CqlPreparedResult success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_prepare_cql_query_result__isset __isset;
+
+  void __set_success(const CqlPreparedResult& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_prepare_cql_query_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_prepare_cql_query_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_prepare_cql_query_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_prepare_cql_query_presult__isset {
+  _Cassandra_prepare_cql_query_presult__isset() : success(false), failure(false), ire(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+} _Cassandra_prepare_cql_query_presult__isset;
+
+class Cassandra_prepare_cql_query_presult {
+ public:
+
+
+  virtual ~Cassandra_prepare_cql_query_presult() throw() {}
+
+  CqlPreparedResult* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_prepare_cql_query_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_execute_prepared_cql_query_args {
+ public:
+
+  Cassandra_execute_prepared_cql_query_args() : itemId(0) {
+  }
+
+  virtual ~Cassandra_execute_prepared_cql_query_args() throw() {}
+
+  int32_t itemId;
+  std::vector<std::string>  values;
+
+  void __set_itemId(const int32_t val) {
+    itemId = val;
+  }
+
+  void __set_values(const std::vector<std::string> & val) {
+    values = val;
+  }
+
+  bool operator == (const Cassandra_execute_prepared_cql_query_args & rhs) const
+  {
+    if (!(itemId == rhs.itemId))
+      return false;
+    if (!(values == rhs.values))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_execute_prepared_cql_query_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_execute_prepared_cql_query_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_execute_prepared_cql_query_pargs {
+ public:
+
+
+  virtual ~Cassandra_execute_prepared_cql_query_pargs() throw() {}
+
+  const int32_t* itemId;
+  const std::vector<std::string> * values;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_execute_prepared_cql_query_result__isset {
+  _Cassandra_execute_prepared_cql_query_result__isset() : success(false), failure(false), ire(false), ue(false), te(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+  bool sde;
+} _Cassandra_execute_prepared_cql_query_result__isset;
+
+class Cassandra_execute_prepared_cql_query_result {
+ public:
+
+  Cassandra_execute_prepared_cql_query_result() {
+  }
+
+  virtual ~Cassandra_execute_prepared_cql_query_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef const CqlResult& success_constref_nonvoid_t;
+  typedef const CqlResult& success_constref_t;
+  typedef CqlResult success_nonvoid_t;
+  typedef CqlResult success_t;
+  CqlResult success;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+  SchemaDisagreementException sde;
+
+  _Cassandra_execute_prepared_cql_query_result__isset __isset;
+
+  void __set_success(const CqlResult& val) {
+    success = val;
+  }
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ue(const UnavailableException& val) {
+    ue = val;
+  }
+
+  void __set_te(const TimedOutException& val) {
+    te = val;
+  }
+
+  void __set_sde(const SchemaDisagreementException& val) {
+    sde = val;
+  }
+
+  bool operator == (const Cassandra_execute_prepared_cql_query_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ue == rhs.ue))
+      return false;
+    if (!(te == rhs.te))
+      return false;
+    if (!(sde == rhs.sde))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_execute_prepared_cql_query_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_execute_prepared_cql_query_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_execute_prepared_cql_query_presult__isset {
+  _Cassandra_execute_prepared_cql_query_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false), sde(false) {}
+  bool success;
+  bool failure;
+  bool ire;
+  bool ue;
+  bool te;
+  bool sde;
+} _Cassandra_execute_prepared_cql_query_presult__isset;
+
+class Cassandra_execute_prepared_cql_query_presult {
+ public:
+
+
+  virtual ~Cassandra_execute_prepared_cql_query_presult() throw() {}
+
+  CqlResult* success;
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+  UnavailableException ue;
+  TimedOutException te;
+  SchemaDisagreementException sde;
+
+  _Cassandra_execute_prepared_cql_query_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Cassandra_set_cql_version_args {
+ public:
+
+  Cassandra_set_cql_version_args() : version() {
+  }
+
+  virtual ~Cassandra_set_cql_version_args() throw() {}
+
+  std::string version;
+
+  void __set_version(const std::string& val) {
+    version = val;
+  }
+
+  bool operator == (const Cassandra_set_cql_version_args & rhs) const
+  {
+    if (!(version == rhs.version))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_set_cql_version_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_set_cql_version_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Cassandra_set_cql_version_pargs {
+ public:
+
+
+  virtual ~Cassandra_set_cql_version_pargs() throw() {}
+
+  const std::string* version;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_set_cql_version_result__isset {
+  _Cassandra_set_cql_version_result__isset() : failure(false), ire(false) {}
+  bool failure;
+  bool ire;
+} _Cassandra_set_cql_version_result__isset;
+
+class Cassandra_set_cql_version_result {
+ public:
+
+  Cassandra_set_cql_version_result() {
+  }
+
+  virtual ~Cassandra_set_cql_version_result() throw() {}
+
+  typedef apache::thrift::TApplicationException failure_t;
+  typedef bool success_constref_nonvoid_t;
+  typedef void success_constref_t;
+  typedef bool success_nonvoid_t;
+  typedef void success_t;
+  apache::thrift::TApplicationException failure;
+  InvalidRequestException ire;
+
+  _Cassandra_set_cql_version_result__isset __isset;
+
+  void __set_failure(const apache::thrift::TApplicationException& val) {
+    failure = val;
+  }
+
+  void __set_ire(const InvalidRequestException& val) {
+    ire = val;
+  }
+
+  bool operator == (const Cassandra_set_cql_version_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    return true;
+  }
+  bool operator != (const Cassandra_set_cql_version_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Cassandra_set_cql_version_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Cassandra_set_cql_version_presult__isset {
+  _Cassandra_set_cql_version_presult__isset() : failure(false), ire(false) {}
+  bool failure;
+  bool ire;
+} _Cassandra_set_cql_version_presult__isset;
+
+class Cassandra_set_cql_version_presult {
+ public:
+
+
+  virtual ~Cassandra_set_cql_version_presult() throw() {}
+
+  apache::thrift::TApplicationException* failure;
+  InvalidRequestException ire;
+
+  _Cassandra_set_cql_version_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class CassandraClient : virtual public CassandraIf {
+ public:
+  CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
+    piprot_(prot),
+    poprot_(prot) {
+    iprot_ = prot.get();
+    oprot_ = prot.get();
+  }
+  CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
+    piprot_(iprot),
+    poprot_(oprot) {
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void login(const AuthenticationRequest& auth_request);
+  void send_login(const AuthenticationRequest& auth_request);
+  void recv_login();
+  void set_keyspace(const std::string& keyspace);
+  void send_set_keyspace(const std::string& keyspace);
+  void recv_set_keyspace();
+  void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level);
+  void send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level);
+  void recv_get(ColumnOrSuperColumn& _return);
+  void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void recv_get_slice(std::vector<ColumnOrSuperColumn> & _return);
+  int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  int32_t recv_get_count();
+  void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void recv_multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return);
+  void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void recv_multiget_count(std::map<std::string, int32_t> & _return);
+  void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level);
+  void send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level);
+  void recv_get_range_slices(std::vector<KeySlice> & _return);
+  void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level);
+  void send_get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level);
+  void recv_get_paged_slice(std::vector<KeySlice> & _return);
+  void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level);
+  void send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level);
+  void recv_get_indexed_slices(std::vector<KeySlice> & _return);
+  void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level);
+  void send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level);
+  void recv_insert();
+  void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level);
+  void send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level);
+  void recv_add();
+  void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level);
+  void send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level);
+  void recv_remove();
+  void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level);
+  void send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level);
+  void recv_remove_counter();
+  void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level);
+  void send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level);
+  void recv_batch_mutate();
+  void truncate(const std::string& cfname);
+  void send_truncate(const std::string& cfname);
+  void recv_truncate();
+  void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return);
+  void send_describe_schema_versions();
+  void recv_describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return);
+  void describe_keyspaces(std::vector<KsDef> & _return);
+  void send_describe_keyspaces();
+  void recv_describe_keyspaces(std::vector<KsDef> & _return);
+  void describe_cluster_name(std::string& _return);
+  void send_describe_cluster_name();
+  void recv_describe_cluster_name(std::string& _return);
+  void describe_version(std::string& _return);
+  void send_describe_version();
+  void recv_describe_version(std::string& _return);
+  void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace);
+  void send_describe_ring(const std::string& keyspace);
+  void recv_describe_ring(std::vector<TokenRange> & _return);
+  void describe_token_map(std::map<std::string, std::string> & _return);
+  void send_describe_token_map();
+  void recv_describe_token_map(std::map<std::string, std::string> & _return);
+  void describe_partitioner(std::string& _return);
+  void send_describe_partitioner();
+  void recv_describe_partitioner(std::string& _return);
+  void describe_snitch(std::string& _return);
+  void send_describe_snitch();
+  void recv_describe_snitch(std::string& _return);
+  void describe_keyspace(KsDef& _return, const std::string& keyspace);
+  void send_describe_keyspace(const std::string& keyspace);
+  void recv_describe_keyspace(KsDef& _return);
+  void describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split);
+  void send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split);
+  void recv_describe_splits(std::vector<std::string> & _return);
+  void system_add_column_family(std::string& _return, const CfDef& cf_def);
+  void send_system_add_column_family(const CfDef& cf_def);
+  void recv_system_add_column_family(std::string& _return);
+  void system_drop_column_family(std::string& _return, const std::string& column_family);
+  void send_system_drop_column_family(const std::string& column_family);
+  void recv_system_drop_column_family(std::string& _return);
+  void system_add_keyspace(std::string& _return, const KsDef& ks_def);
+  void send_system_add_keyspace(const KsDef& ks_def);
+  void recv_system_add_keyspace(std::string& _return);
+  void system_drop_keyspace(std::string& _return, const std::string& keyspace);
+  void send_system_drop_keyspace(const std::string& keyspace);
+  void recv_system_drop_keyspace(std::string& _return);
+  void system_update_keyspace(std::string& _return, const KsDef& ks_def);
+  void send_system_update_keyspace(const KsDef& ks_def);
+  void recv_system_update_keyspace(std::string& _return);
+  void system_update_column_family(std::string& _return, const CfDef& cf_def);
+  void send_system_update_column_family(const CfDef& cf_def);
+  void recv_system_update_column_family(std::string& _return);
+  void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression);
+  void send_execute_cql_query(const std::string& query, const Compression::type compression);
+  void recv_execute_cql_query(CqlResult& _return);
+  void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression);
+  void send_prepare_cql_query(const std::string& query, const Compression::type compression);
+  void recv_prepare_cql_query(CqlPreparedResult& _return);
+  void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values);
+  void send_execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values);
+  void recv_execute_prepared_cql_query(CqlResult& _return);
+  void set_cql_version(const std::string& version);
+  void send_set_cql_version(const std::string& version);
+  void recv_set_cql_version();
+ protected:
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class CassandraProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+  boost::shared_ptr<CassandraIf> iface_;
+  virtual bool dispatchCall(apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+  typedef  void (CassandraProcessor::*ProcessFunction)(int32_t, apache::thrift::protocol::TProtocol*, apache::thrift::protocol::TProtocol*, void*);
+  typedef std::map<std::string, ProcessFunction> ProcessMap;
+  ProcessMap processMap_;
+  void process_login(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_set_keyspace(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_slice(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_count(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_multiget_slice(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_multiget_count(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_range_slices(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_paged_slice(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_indexed_slices(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_insert(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_add(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_remove(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_remove_counter(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_batch_mutate(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_truncate(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_schema_versions(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_keyspaces(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_cluster_name(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_version(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_ring(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_token_map(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_partitioner(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_snitch(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_keyspace(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_describe_splits(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_system_add_column_family(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_system_drop_column_family(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_system_add_keyspace(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_system_drop_keyspace(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_system_update_keyspace(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_system_update_column_family(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_execute_cql_query(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_prepare_cql_query(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_execute_prepared_cql_query(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_set_cql_version(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ public:
+  CassandraProcessor(boost::shared_ptr<CassandraIf> iface) :
+    iface_(iface) {
+    processMap_["login"] = &CassandraProcessor::process_login;
+    processMap_["set_keyspace"] = &CassandraProcessor::process_set_keyspace;
+    processMap_["get"] = &CassandraProcessor::process_get;
+    processMap_["get_slice"] = &CassandraProcessor::process_get_slice;
+    processMap_["get_count"] = &CassandraProcessor::process_get_count;
+    processMap_["multiget_slice"] = &CassandraProcessor::process_multiget_slice;
+    processMap_["multiget_count"] = &CassandraProcessor::process_multiget_count;
+    processMap_["get_range_slices"] = &CassandraProcessor::process_get_range_slices;
+    processMap_["get_paged_slice"] = &CassandraProcessor::process_get_paged_slice;
+    processMap_["get_indexed_slices"] = &CassandraProcessor::process_get_indexed_slices;
+    processMap_["insert"] = &CassandraProcessor::process_insert;
+    processMap_["add"] = &CassandraProcessor::process_add;
+    processMap_["remove"] = &CassandraProcessor::process_remove;
+    processMap_["remove_counter"] = &CassandraProcessor::process_remove_counter;
+    processMap_["batch_mutate"] = &CassandraProcessor::process_batch_mutate;
+    processMap_["truncate"] = &CassandraProcessor::process_truncate;
+    processMap_["describe_schema_versions"] = &CassandraProcessor::process_describe_schema_versions;
+    processMap_["describe_keyspaces"] = &CassandraProcessor::process_describe_keyspaces;
+    processMap_["describe_cluster_name"] = &CassandraProcessor::process_describe_cluster_name;
+    processMap_["describe_version"] = &CassandraProcessor::process_describe_version;
+    processMap_["describe_ring"] = &CassandraProcessor::process_describe_ring;
+    processMap_["describe_token_map"] = &CassandraProcessor::process_describe_token_map;
+    processMap_["describe_partitioner"] = &CassandraProcessor::process_describe_partitioner;
+    processMap_["describe_snitch"] = &CassandraProcessor::process_describe_snitch;
+    processMap_["describe_keyspace"] = &CassandraProcessor::process_describe_keyspace;
+    processMap_["describe_splits"] = &CassandraProcessor::process_describe_splits;
+    processMap_["system_add_column_family"] = &CassandraProcessor::process_system_add_column_family;
+    processMap_["system_drop_column_family"] = &CassandraProcessor::process_system_drop_column_family;
+    processMap_["system_add_keyspace"] = &CassandraProcessor::process_system_add_keyspace;
+    processMap_["system_drop_keyspace"] = &CassandraProcessor::process_system_drop_keyspace;
+    processMap_["system_update_keyspace"] = &CassandraProcessor::process_system_update_keyspace;
+    processMap_["system_update_column_family"] = &CassandraProcessor::process_system_update_column_family;
+    processMap_["execute_cql_query"] = &CassandraProcessor::process_execute_cql_query;
+    processMap_["prepare_cql_query"] = &CassandraProcessor::process_prepare_cql_query;
+    processMap_["execute_prepared_cql_query"] = &CassandraProcessor::process_execute_prepared_cql_query;
+    processMap_["set_cql_version"] = &CassandraProcessor::process_set_cql_version;
+  }
+
+  virtual ~CassandraProcessor() {}
+};
+
+class CassandraProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+  CassandraProcessorFactory(const ::boost::shared_ptr< CassandraIfFactory >& handlerFactory) :
+      handlerFactory_(handlerFactory) {}
+
+  ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+  ::boost::shared_ptr< CassandraIfFactory > handlerFactory_;
+};
+
+class CassandraMultiface : virtual public CassandraIf {
+ public:
+  CassandraMultiface(std::vector<boost::shared_ptr<CassandraIf> >& ifaces) : ifaces_(ifaces) {
+  }
+  virtual ~CassandraMultiface() {}
+ protected:
+  std::vector<boost::shared_ptr<CassandraIf> > ifaces_;
+  CassandraMultiface() {}
+  void add(boost::shared_ptr<CassandraIf> iface) {
+    ifaces_.push_back(iface);
+  }
+ public:
+  void login(const AuthenticationRequest& auth_request) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->login(auth_request);
+    }
+    ifaces_[i]->login(auth_request);
+  }
+
+  void set_keyspace(const std::string& keyspace) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->set_keyspace(keyspace);
+    }
+    ifaces_[i]->set_keyspace(keyspace);
+  }
+
+  void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get(_return, key, column_path, consistency_level);
+    }
+    ifaces_[i]->get(_return, key, column_path, consistency_level);
+    return;
+  }
+
+  void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level);
+    }
+    ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level);
+    return;
+  }
+
+  int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_count(key, column_parent, predicate, consistency_level);
+    }
+    return ifaces_[i]->get_count(key, column_parent, predicate, consistency_level);
+  }
+
+  void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level);
+    }
+    ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level);
+    return;
+  }
+
+  void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level);
+    }
+    ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level);
+    return;
+  }
+
+  void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level);
+    }
+    ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level);
+    return;
+  }
+
+  void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_paged_slice(_return, column_family, range, start_column, consistency_level);
+    }
+    ifaces_[i]->get_paged_slice(_return, column_family, range, start_column, consistency_level);
+    return;
+  }
+
+  void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level);
+    }
+    ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level);
+    return;
+  }
+
+  void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->insert(key, column_parent, column, consistency_level);
+    }
+    ifaces_[i]->insert(key, column_parent, column, consistency_level);
+  }
+
+  void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->add(key, column_parent, column, consistency_level);
+    }
+    ifaces_[i]->add(key, column_parent, column, consistency_level);
+  }
+
+  void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->remove(key, column_path, timestamp, consistency_level);
+    }
+    ifaces_[i]->remove(key, column_path, timestamp, consistency_level);
+  }
+
+  void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->remove_counter(key, path, consistency_level);
+    }
+    ifaces_[i]->remove_counter(key, path, consistency_level);
+  }
+
+  void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->batch_mutate(mutation_map, consistency_level);
+    }
+    ifaces_[i]->batch_mutate(mutation_map, consistency_level);
+  }
+
+  void truncate(const std::string& cfname) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->truncate(cfname);
+    }
+    ifaces_[i]->truncate(cfname);
+  }
+
+  void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_schema_versions(_return);
+    }
+    ifaces_[i]->describe_schema_versions(_return);
+    return;
+  }
+
+  void describe_keyspaces(std::vector<KsDef> & _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_keyspaces(_return);
+    }
+    ifaces_[i]->describe_keyspaces(_return);
+    return;
+  }
+
+  void describe_cluster_name(std::string& _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_cluster_name(_return);
+    }
+    ifaces_[i]->describe_cluster_name(_return);
+    return;
+  }
+
+  void describe_version(std::string& _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_version(_return);
+    }
+    ifaces_[i]->describe_version(_return);
+    return;
+  }
+
+  void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_ring(_return, keyspace);
+    }
+    ifaces_[i]->describe_ring(_return, keyspace);
+    return;
+  }
+
+  void describe_token_map(std::map<std::string, std::string> & _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_token_map(_return);
+    }
+    ifaces_[i]->describe_token_map(_return);
+    return;
+  }
+
+  void describe_partitioner(std::string& _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_partitioner(_return);
+    }
+    ifaces_[i]->describe_partitioner(_return);
+    return;
+  }
+
+  void describe_snitch(std::string& _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_snitch(_return);
+    }
+    ifaces_[i]->describe_snitch(_return);
+    return;
+  }
+
+  void describe_keyspace(KsDef& _return, const std::string& keyspace) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_keyspace(_return, keyspace);
+    }
+    ifaces_[i]->describe_keyspace(_return, keyspace);
+    return;
+  }
+
+  void describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split);
+    }
+    ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split);
+    return;
+  }
+
+  void system_add_column_family(std::string& _return, const CfDef& cf_def) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->system_add_column_family(_return, cf_def);
+    }
+    ifaces_[i]->system_add_column_family(_return, cf_def);
+    return;
+  }
+
+  void system_drop_column_family(std::string& _return, const std::string& column_family) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->system_drop_column_family(_return, column_family);
+    }
+    ifaces_[i]->system_drop_column_family(_return, column_family);
+    return;
+  }
+
+  void system_add_keyspace(std::string& _return, const KsDef& ks_def) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->system_add_keyspace(_return, ks_def);
+    }
+    ifaces_[i]->system_add_keyspace(_return, ks_def);
+    return;
+  }
+
+  void system_drop_keyspace(std::string& _return, const std::string& keyspace) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->system_drop_keyspace(_return, keyspace);
+    }
+    ifaces_[i]->system_drop_keyspace(_return, keyspace);
+    return;
+  }
+
+  void system_update_keyspace(std::string& _return, const KsDef& ks_def) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->system_update_keyspace(_return, ks_def);
+    }
+    ifaces_[i]->system_update_keyspace(_return, ks_def);
+    return;
+  }
+
+  void system_update_column_family(std::string& _return, const CfDef& cf_def) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->system_update_column_family(_return, cf_def);
+    }
+    ifaces_[i]->system_update_column_family(_return, cf_def);
+    return;
+  }
+
+  void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->execute_cql_query(_return, query, compression);
+    }
+    ifaces_[i]->execute_cql_query(_return, query, compression);
+    return;
+  }
+
+  void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->prepare_cql_query(_return, query, compression);
+    }
+    ifaces_[i]->prepare_cql_query(_return, query, compression);
+    return;
+  }
+
+  void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->execute_prepared_cql_query(_return, itemId, values);
+    }
+    ifaces_[i]->execute_prepared_cql_query(_return, itemId, values);
+    return;
+  }
+
+  void set_cql_version(const std::string& version) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->set_cql_version(version);
+    }
+    ifaces_[i]->set_cql_version(version);
+  }
+
+};
+
+class CassandraAsyncIf {
+ public:
+  typedef apache::thrift::async::TSharedPromise<Cassandra_login_result> login_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_login_result> login_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_set_keyspace_result> set_keyspace_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_set_keyspace_result> set_keyspace_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_get_result> get_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_get_result> get_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_get_slice_result> get_slice_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_get_slice_result> get_slice_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_get_count_result> get_count_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_get_count_result> get_count_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_multiget_slice_result> multiget_slice_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_multiget_slice_result> multiget_slice_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_multiget_count_result> multiget_count_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_multiget_count_result> multiget_count_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_get_range_slices_result> get_range_slices_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_get_range_slices_result> get_range_slices_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_get_paged_slice_result> get_paged_slice_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_get_paged_slice_result> get_paged_slice_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_get_indexed_slices_result> get_indexed_slices_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_get_indexed_slices_result> get_indexed_slices_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_insert_result> insert_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_insert_result> insert_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_add_result> add_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_add_result> add_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_remove_result> remove_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_remove_result> remove_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_remove_counter_result> remove_counter_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_remove_counter_result> remove_counter_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_batch_mutate_result> batch_mutate_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_batch_mutate_result> batch_mutate_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_truncate_result> truncate_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_truncate_result> truncate_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_schema_versions_result> describe_schema_versions_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_schema_versions_result> describe_schema_versions_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_keyspaces_result> describe_keyspaces_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_keyspaces_result> describe_keyspaces_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_cluster_name_result> describe_cluster_name_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_cluster_name_result> describe_cluster_name_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_version_result> describe_version_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_version_result> describe_version_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_ring_result> describe_ring_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_ring_result> describe_ring_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_token_map_result> describe_token_map_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_token_map_result> describe_token_map_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_partitioner_result> describe_partitioner_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_partitioner_result> describe_partitioner_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_snitch_result> describe_snitch_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_snitch_result> describe_snitch_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_keyspace_result> describe_keyspace_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_keyspace_result> describe_keyspace_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_describe_splits_result> describe_splits_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_describe_splits_result> describe_splits_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_system_add_column_family_result> system_add_column_family_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_system_add_column_family_result> system_add_column_family_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_system_drop_column_family_result> system_drop_column_family_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_system_drop_column_family_result> system_drop_column_family_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_system_add_keyspace_result> system_add_keyspace_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_system_add_keyspace_result> system_add_keyspace_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_system_drop_keyspace_result> system_drop_keyspace_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_system_drop_keyspace_result> system_drop_keyspace_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_system_update_keyspace_result> system_update_keyspace_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_system_update_keyspace_result> system_update_keyspace_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_system_update_column_family_result> system_update_column_family_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_system_update_column_family_result> system_update_column_family_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_execute_cql_query_result> execute_cql_query_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_execute_cql_query_result> execute_cql_query_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_prepare_cql_query_result> prepare_cql_query_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_prepare_cql_query_result> prepare_cql_query_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_execute_prepared_cql_query_result> execute_prepared_cql_query_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_execute_prepared_cql_query_result> execute_prepared_cql_query_shared_future_t;
+  typedef apache::thrift::async::TSharedPromise<Cassandra_set_cql_version_result> set_cql_version_shared_promise_t;
+  typedef apache::thrift::async::TSharedFuture<Cassandra_set_cql_version_result> set_cql_version_shared_future_t;
+
+  virtual ~CassandraAsyncIf() {}
+  virtual login_shared_future_t login(const AuthenticationRequest& auth_request) = 0;
+  virtual set_keyspace_shared_future_t set_keyspace(const std::string& keyspace) = 0;
+  virtual get_shared_future_t get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) = 0;
+  virtual get_slice_shared_future_t get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual get_count_shared_future_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual multiget_slice_shared_future_t multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual multiget_count_shared_future_t multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual get_range_slices_shared_future_t get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) = 0;
+  virtual get_paged_slice_shared_future_t get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) = 0;
+  virtual get_indexed_slices_shared_future_t get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) = 0;
+  virtual insert_shared_future_t insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) = 0;
+  virtual add_shared_future_t add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) = 0;
+  virtual remove_shared_future_t remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) = 0;
+  virtual remove_counter_shared_future_t remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) = 0;
+  virtual batch_mutate_shared_future_t batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) = 0;
+  virtual truncate_shared_future_t truncate(const std::string& cfname) = 0;
+  virtual describe_schema_versions_shared_future_t describe_schema_versions() = 0;
+  virtual describe_keyspaces_shared_future_t describe_keyspaces() = 0;
+  virtual describe_cluster_name_shared_future_t describe_cluster_name() = 0;
+  virtual describe_version_shared_future_t describe_version() = 0;
+  virtual describe_ring_shared_future_t describe_ring(const std::string& keyspace) = 0;
+  virtual describe_token_map_shared_future_t describe_token_map() = 0;
+  virtual describe_partitioner_shared_future_t describe_partitioner() = 0;
+  virtual describe_snitch_shared_future_t describe_snitch() = 0;
+  virtual describe_keyspace_shared_future_t describe_keyspace(const std::string& keyspace) = 0;
+  virtual describe_splits_shared_future_t describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) = 0;
+  virtual system_add_column_family_shared_future_t system_add_column_family(const CfDef& cf_def) = 0;
+  virtual system_drop_column_family_shared_future_t system_drop_column_family(const std::string& column_family) = 0;
+  virtual system_add_keyspace_shared_future_t system_add_keyspace(const KsDef& ks_def) = 0;
+  virtual system_drop_keyspace_shared_future_t system_drop_keyspace(const std::string& keyspace) = 0;
+  virtual system_update_keyspace_shared_future_t system_update_keyspace(const KsDef& ks_def) = 0;
+  virtual system_update_column_family_shared_future_t system_update_column_family(const CfDef& cf_def) = 0;
+  virtual execute_cql_query_shared_future_t execute_cql_query(const std::string& query, const Compression::type compression) = 0;
+  virtual prepare_cql_query_shared_future_t prepare_cql_query(const std::string& query, const Compression::type compression) = 0;
+  virtual execute_prepared_cql_query_shared_future_t execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values) = 0;
+  virtual set_cql_version_shared_future_t set_cql_version(const std::string& version) = 0;
+
+  typedef Cassandra_login_result login_result;
+  static login_result login_failure(apache::thrift::TApplicationException failure);
+  static login_result login_authnx(AuthenticationException authnx);
+  static login_result login_authzx(AuthorizationException authzx);
+  typedef Cassandra_set_keyspace_result set_keyspace_result;
+  static set_keyspace_result set_keyspace_failure(apache::thrift::TApplicationException failure);
+  static set_keyspace_result set_keyspace_ire(InvalidRequestException ire);
+  typedef Cassandra_get_result get_result;
+  static get_result get_failure(apache::thrift::TApplicationException failure);
+  static get_result get_success(ColumnOrSuperColumn success);
+  static get_result get_ire(InvalidRequestException ire);
+  static get_result get_nfe(NotFoundException nfe);
+  static get_result get_ue(UnavailableException ue);
+  static get_result get_te(TimedOutException te);
+  typedef Cassandra_get_slice_result get_slice_result;
+  static get_slice_result get_slice_failure(apache::thrift::TApplicationException failure);
+  static get_slice_result get_slice_success(std::vector<ColumnOrSuperColumn>  success);
+  static get_slice_result get_slice_ire(InvalidRequestException ire);
+  static get_slice_result get_slice_ue(UnavailableException ue);
+  static get_slice_result get_slice_te(TimedOutException te);
+  typedef Cassandra_get_count_result get_count_result;
+  static get_count_result get_count_failure(apache::thrift::TApplicationException failure);
+  static get_count_result get_count_success(int32_t success);
+  static get_count_result get_count_ire(InvalidRequestException ire);
+  static get_count_result get_count_ue(UnavailableException ue);
+  static get_count_result get_count_te(TimedOutException te);
+  typedef Cassandra_multiget_slice_result multiget_slice_result;
+  static multiget_slice_result multiget_slice_failure(apache::thrift::TApplicationException failure);
+  static multiget_slice_result multiget_slice_success(std::map<std::string, std::vector<ColumnOrSuperColumn> >  success);
+  static multiget_slice_result multiget_slice_ire(InvalidRequestException ire);
+  static multiget_slice_result multiget_slice_ue(UnavailableException ue);
+  static multiget_slice_result multiget_slice_te(TimedOutException te);
+  typedef Cassandra_multiget_count_result multiget_count_result;
+  static multiget_count_result multiget_count_failure(apache::thrift::TApplicationException failure);
+  static multiget_count_result multiget_count_success(std::map<std::string, int32_t>  success);
+  static multiget_count_result multiget_count_ire(InvalidRequestException ire);
+  static multiget_count_result multiget_count_ue(UnavailableException ue);
+  static multiget_count_result multiget_count_te(TimedOutException te);
+  typedef Cassandra_get_range_slices_result get_range_slices_result;
+  static get_range_slices_result get_range_slices_failure(apache::thrift::TApplicationException failure);
+  static get_range_slices_result get_range_slices_success(std::vector<KeySlice>  success);
+  static get_range_slices_result get_range_slices_ire(InvalidRequestException ire);
+  static get_range_slices_result get_range_slices_ue(UnavailableException ue);
+  static get_range_slices_result get_range_slices_te(TimedOutException te);
+  typedef Cassandra_get_paged_slice_result get_paged_slice_result;
+  static get_paged_slice_result get_paged_slice_failure(apache::thrift::TApplicationException failure);
+  static get_paged_slice_result get_paged_slice_success(std::vector<KeySlice>  success);
+  static get_paged_slice_result get_paged_slice_ire(InvalidRequestException ire);
+  static get_paged_slice_result get_paged_slice_ue(UnavailableException ue);
+  static get_paged_slice_result get_paged_slice_te(TimedOutException te);
+  typedef Cassandra_get_indexed_slices_result get_indexed_slices_result;
+  static get_indexed_slices_result get_indexed_slices_failure(apache::thrift::TApplicationException failure);
+  static get_indexed_slices_result get_indexed_slices_success(std::vector<KeySlice>  success);
+  static get_indexed_slices_result get_indexed_slices_ire(InvalidRequestException ire);
+  static get_indexed_slices_result get_indexed_slices_ue(UnavailableException ue);
+  static get_indexed_slices_result get_indexed_slices_te(TimedOutException te);
+  typedef Cassandra_insert_result insert_result;
+  static insert_result insert_failure(apache::thrift::TApplicationException failure);
+  static insert_result insert_ire(InvalidRequestException ire);
+  static insert_result insert_ue(UnavailableException ue);
+  static insert_result insert_te(TimedOutException te);
+  typedef Cassandra_add_result add_result;
+  static add_result add_failure(apache::thrift::TApplicationException failure);
+  static add_result add_ire(InvalidRequestException ire);
+  static add_result add_ue(UnavailableException ue);
+  static add_result add_te(TimedOutException te);
+  typedef Cassandra_remove_result remove_result;
+  static remove_result remove_failure(apache::thrift::TApplicationException failure);
+  static remove_result remove_ire(InvalidRequestException ire);
+  static remove_result remove_ue(UnavailableException ue);
+  static remove_result remove_te(TimedOutException te);
+  typedef Cassandra_remove_counter_result remove_counter_result;
+  static remove_counter_result remove_counter_failure(apache::thrift::TApplicationException failure);
+  static remove_counter_result remove_counter_ire(InvalidRequestException ire);
+  static remove_counter_result remove_counter_ue(UnavailableException ue);
+  static remove_counter_result remove_counter_te(TimedOutException te);
+  typedef Cassandra_batch_mutate_result batch_mutate_result;
+  static batch_mutate_result batch_mutate_failure(apache::thrift::TApplicationException failure);
+  static batch_mutate_result batch_mutate_ire(InvalidRequestException ire);
+  static batch_mutate_result batch_mutate_ue(UnavailableException ue);
+  static batch_mutate_result batch_mutate_te(TimedOutException te);
+  typedef Cassandra_truncate_result truncate_result;
+  static truncate_result truncate_failure(apache::thrift::TApplicationException failure);
+  static truncate_result truncate_ire(InvalidRequestException ire);
+  static truncate_result truncate_ue(UnavailableException ue);
+  static truncate_result truncate_te(TimedOutException te);
+  typedef Cassandra_describe_schema_versions_result describe_schema_versions_result;
+  static describe_schema_versions_result describe_schema_versions_failure(apache::thrift::TApplicationException failure);
+  static describe_schema_versions_result describe_schema_versions_success(std::map<std::string, std::vector<std::string> >  success);
+  static describe_schema_versions_result describe_schema_versions_ire(InvalidRequestException ire);
+  typedef Cassandra_describe_keyspaces_result describe_keyspaces_result;
+  static describe_keyspaces_result describe_keyspaces_failure(apache::thrift::TApplicationException failure);
+  static describe_keyspaces_result describe_keyspaces_success(std::vector<KsDef>  success);
+  static describe_keyspaces_result describe_keyspaces_ire(InvalidRequestException ire);
+  typedef Cassandra_describe_cluster_name_result describe_cluster_name_result;
+  static describe_cluster_name_result describe_cluster_name_failure(apache::thrift::TApplicationException failure);
+  static describe_cluster_name_result describe_cluster_name_success(std::string success);
+  typedef Cassandra_describe_version_result describe_version_result;
+  static describe_version_result describe_version_failure(apache::thrift::TApplicationException failure);
+  static describe_version_result describe_version_success(std::string success);
+  typedef Cassandra_describe_ring_result describe_ring_result;
+  static describe_ring_result describe_ring_failure(apache::thrift::TApplicationException failure);
+  static describe_ring_result describe_ring_success(std::vector<TokenRange>  success);
+  static describe_ring_result describe_ring_ire(InvalidRequestException ire);
+  typedef Cassandra_describe_token_map_result describe_token_map_result;
+  static describe_token_map_result describe_token_map_failure(apache::thrift::TApplicationException failure);
+  static describe_token_map_result describe_token_map_success(std::map<std::string, std::string>  success);
+  static describe_token_map_result describe_token_map_ire(InvalidRequestException ire);
+  typedef Cassandra_describe_partitioner_result describe_partitioner_result;
+  static describe_partitioner_result describe_partitioner_failure(apache::thrift::TApplicationException failure);
+  static describe_partitioner_result describe_partitioner_success(std::string success);
+  typedef Cassandra_describe_snitch_result describe_snitch_result;
+  static describe_snitch_result describe_snitch_failure(apache::thrift::TApplicationException failure);
+  static describe_snitch_result describe_snitch_success(std::string success);
+  typedef Cassandra_describe_keyspace_result describe_keyspace_result;
+  static describe_keyspace_result describe_keyspace_failure(apache::thrift::TApplicationException failure);
+  static describe_keyspace_result describe_keyspace_success(KsDef success);
+  static describe_keyspace_result describe_keyspace_nfe(NotFoundException nfe);
+  static describe_keyspace_result describe_keyspace_ire(InvalidRequestException ire);
+  typedef Cassandra_describe_splits_result describe_splits_result;
+  static describe_splits_result describe_splits_failure(apache::thrift::TApplicationException failure);
+  static describe_splits_result describe_splits_success(std::vector<std::string>  success);
+  static describe_splits_result describe_splits_ire(InvalidRequestException ire);
+  typedef Cassandra_system_add_column_family_result system_add_column_family_result;
+  static system_add_column_family_result system_add_column_family_failure(apache::thrift::TApplicationException failure);
+  static system_add_column_family_result system_add_column_family_success(std::string success);
+  static system_add_column_family_result system_add_column_family_ire(InvalidRequestException ire);
+  static system_add_column_family_result system_add_column_family_sde(SchemaDisagreementException sde);
+  typedef Cassandra_system_drop_column_family_result system_drop_column_family_result;
+  static system_drop_column_family_result system_drop_column_family_failure(apache::thrift::TApplicationException failure);
+  static system_drop_column_family_result system_drop_column_family_success(std::string success);
+  static system_drop_column_family_result system_drop_column_family_ire(InvalidRequestException ire);
+  static system_drop_column_family_result system_drop_column_family_sde(SchemaDisagreementException sde);
+  typedef Cassandra_system_add_keyspace_result system_add_keyspace_result;
+  static system_add_keyspace_result system_add_keyspace_failure(apache::thrift::TApplicationException failure);
+  static system_add_keyspace_result system_add_keyspace_success(std::string success);
+  static system_add_keyspace_result system_add_keyspace_ire(InvalidRequestException ire);
+  static system_add_keyspace_result system_add_keyspace_sde(SchemaDisagreementException sde);
+  typedef Cassandra_system_drop_keyspace_result system_drop_keyspace_result;
+  static system_drop_keyspace_result system_drop_keyspace_failure(apache::thrift::TApplicationException failure);
+  static system_drop_keyspace_result system_drop_keyspace_success(std::string success);
+  static system_drop_keyspace_result system_drop_keyspace_ire(InvalidRequestException ire);
+  static system_drop_keyspace_result system_drop_keyspace_sde(SchemaDisagreementException sde);
+  typedef Cassandra_system_update_keyspace_result system_update_keyspace_result;
+  static system_update_keyspace_result system_update_keyspace_failure(apache::thrift::TApplicationException failure);
+  static system_update_keyspace_result system_update_keyspace_success(std::string success);
+  static system_update_keyspace_result system_update_keyspace_ire(InvalidRequestException ire);
+  static system_update_keyspace_result system_update_keyspace_sde(SchemaDisagreementException sde);
+  typedef Cassandra_system_update_column_family_result system_update_column_family_result;
+  static system_update_column_family_result system_update_column_family_failure(apache::thrift::TApplicationException failure);
+  static system_update_column_family_result system_update_column_family_success(std::string success);
+  static system_update_column_family_result system_update_column_family_ire(InvalidRequestException ire);
+  static system_update_column_family_result system_update_column_family_sde(SchemaDisagreementException sde);
+  typedef Cassandra_execute_cql_query_result execute_cql_query_result;
+  static execute_cql_query_result execute_cql_query_failure(apache::thrift::TApplicationException failure);
+  static execute_cql_query_result execute_cql_query_success(CqlResult success);
+  static execute_cql_query_result execute_cql_query_ire(InvalidRequestException ire);
+  static execute_cql_query_result execute_cql_query_ue(UnavailableException ue);
+  static execute_cql_query_result execute_cql_query_te(TimedOutException te);
+  static execute_cql_query_result execute_cql_query_sde(SchemaDisagreementException sde);
+  typedef Cassandra_prepare_cql_query_result prepare_cql_query_result;
+  static prepare_cql_query_result prepare_cql_query_failure(apache::thrift::TApplicationException failure);
+  static prepare_cql_query_result prepare_cql_query_success(CqlPreparedResult success);
+  static prepare_cql_query_result prepare_cql_query_ire(InvalidRequestException ire);
+  typedef Cassandra_execute_prepared_cql_query_result execute_prepared_cql_query_result;
+  static execute_prepared_cql_query_result execute_prepared_cql_query_failure(apache::thrift::TApplicationException failure);
+  static execute_prepared_cql_query_result execute_prepared_cql_query_success(CqlResult success);
+  static execute_prepared_cql_query_result execute_prepared_cql_query_ire(InvalidRequestException ire);
+  static execute_prepared_cql_query_result execute_prepared_cql_query_ue(UnavailableException ue);
+  static execute_prepared_cql_query_result execute_prepared_cql_query_te(TimedOutException te);
+  static execute_prepared_cql_query_result execute_prepared_cql_query_sde(SchemaDisagreementException sde);
+  typedef Cassandra_set_cql_version_result set_cql_version_result;
+  static set_cql_version_result set_cql_version_failure(apache::thrift::TApplicationException failure);
+  static set_cql_version_result set_cql_version_ire(InvalidRequestException ire);
+};
+
+class CassandraAsyncClient : virtual public CassandraAsyncIf, public apache::thrift::TProcessor {
+ public:
+  CassandraAsyncClient(boost::shared_ptr<apache::thrift::transport::TTransport> ot, boost::shared_ptr<apache::thrift::protocol::TProtocolFactory> opf) :
+    potransport_(ot),
+    poprotfact_(opf),
+    request_counter_(0) {
+    otransport_ = ot.get();
+    oprotfact_ = opf.get();
+  }
+  boost::shared_ptr<apache::thrift::transport::TTransport> getOutputTransport() {
+    return potransport_;
+  }
+  boost::shared_ptr<apache::thrift::protocol::TProtocolFactory> getOutputProtocolFactory() {
+    return poprotfact_;
+  }
+  login_shared_future_t login(const AuthenticationRequest& auth_request);
+  void send_login(const AuthenticationRequest& auth_request);
+  void recv_login(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, login_shared_promise_t promise);
+  set_keyspace_shared_future_t set_keyspace(const std::string& keyspace);
+  void send_set_keyspace(const std::string& keyspace);
+  void recv_set_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, set_keyspace_shared_promise_t promise);
+  get_shared_future_t get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level);
+  void send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level);
+  void recv_get(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_shared_promise_t promise);
+  get_slice_shared_future_t get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void recv_get_slice(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_slice_shared_promise_t promise);
+  get_count_shared_future_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void recv_get_count(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_count_shared_promise_t promise);
+  multiget_slice_shared_future_t multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void recv_multiget_slice(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, multiget_slice_shared_promise_t promise);
+  multiget_count_shared_future_t multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
+  void recv_multiget_count(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, multiget_count_shared_promise_t promise);
+  get_range_slices_shared_future_t get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level);
+  void send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level);
+  void recv_get_range_slices(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_range_slices_shared_promise_t promise);
+  get_paged_slice_shared_future_t get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level);
+  void send_get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level);
+  void recv_get_paged_slice(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_paged_slice_shared_promise_t promise);
+  get_indexed_slices_shared_future_t get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level);
+  void send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level);
+  void recv_get_indexed_slices(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, get_indexed_slices_shared_promise_t promise);
+  insert_shared_future_t insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level);
+  void send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level);
+  void recv_insert(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, insert_shared_promise_t promise);
+  add_shared_future_t add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level);
+  void send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level);
+  void recv_add(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, add_shared_promise_t promise);
+  remove_shared_future_t remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level);
+  void send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level);
+  void recv_remove(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, remove_shared_promise_t promise);
+  remove_counter_shared_future_t remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level);
+  void send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level);
+  void recv_remove_counter(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, remove_counter_shared_promise_t promise);
+  batch_mutate_shared_future_t batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level);
+  void send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level);
+  void recv_batch_mutate(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, batch_mutate_shared_promise_t promise);
+  truncate_shared_future_t truncate(const std::string& cfname);
+  void send_truncate(const std::string& cfname);
+  void recv_truncate(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, truncate_shared_promise_t promise);
+  describe_schema_versions_shared_future_t describe_schema_versions();
+  void send_describe_schema_versions();
+  void recv_describe_schema_versions(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_schema_versions_shared_promise_t promise);
+  describe_keyspaces_shared_future_t describe_keyspaces();
+  void send_describe_keyspaces();
+  void recv_describe_keyspaces(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_keyspaces_shared_promise_t promise);
+  describe_cluster_name_shared_future_t describe_cluster_name();
+  void send_describe_cluster_name();
+  void recv_describe_cluster_name(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_cluster_name_shared_promise_t promise);
+  describe_version_shared_future_t describe_version();
+  void send_describe_version();
+  void recv_describe_version(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_version_shared_promise_t promise);
+  describe_ring_shared_future_t describe_ring(const std::string& keyspace);
+  void send_describe_ring(const std::string& keyspace);
+  void recv_describe_ring(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_ring_shared_promise_t promise);
+  describe_token_map_shared_future_t describe_token_map();
+  void send_describe_token_map();
+  void recv_describe_token_map(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_token_map_shared_promise_t promise);
+  describe_partitioner_shared_future_t describe_partitioner();
+  void send_describe_partitioner();
+  void recv_describe_partitioner(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_partitioner_shared_promise_t promise);
+  describe_snitch_shared_future_t describe_snitch();
+  void send_describe_snitch();
+  void recv_describe_snitch(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_snitch_shared_promise_t promise);
+  describe_keyspace_shared_future_t describe_keyspace(const std::string& keyspace);
+  void send_describe_keyspace(const std::string& keyspace);
+  void recv_describe_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_keyspace_shared_promise_t promise);
+  describe_splits_shared_future_t describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split);
+  void send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split);
+  void recv_describe_splits(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, describe_splits_shared_promise_t promise);
+  system_add_column_family_shared_future_t system_add_column_family(const CfDef& cf_def);
+  void send_system_add_column_family(const CfDef& cf_def);
+  void recv_system_add_column_family(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_add_column_family_shared_promise_t promise);
+  system_drop_column_family_shared_future_t system_drop_column_family(const std::string& column_family);
+  void send_system_drop_column_family(const std::string& column_family);
+  void recv_system_drop_column_family(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_drop_column_family_shared_promise_t promise);
+  system_add_keyspace_shared_future_t system_add_keyspace(const KsDef& ks_def);
+  void send_system_add_keyspace(const KsDef& ks_def);
+  void recv_system_add_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_add_keyspace_shared_promise_t promise);
+  system_drop_keyspace_shared_future_t system_drop_keyspace(const std::string& keyspace);
+  void send_system_drop_keyspace(const std::string& keyspace);
+  void recv_system_drop_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_drop_keyspace_shared_promise_t promise);
+  system_update_keyspace_shared_future_t system_update_keyspace(const KsDef& ks_def);
+  void send_system_update_keyspace(const KsDef& ks_def);
+  void recv_system_update_keyspace(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_update_keyspace_shared_promise_t promise);
+  system_update_column_family_shared_future_t system_update_column_family(const CfDef& cf_def);
+  void send_system_update_column_family(const CfDef& cf_def);
+  void recv_system_update_column_family(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, system_update_column_family_shared_promise_t promise);
+  execute_cql_query_shared_future_t execute_cql_query(const std::string& query, const Compression::type compression);
+  void send_execute_cql_query(const std::string& query, const Compression::type compression);
+  void recv_execute_cql_query(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, execute_cql_query_shared_promise_t promise);
+  prepare_cql_query_shared_future_t prepare_cql_query(const std::string& query, const Compression::type compression);
+  void send_prepare_cql_query(const std::string& query, const Compression::type compression);
+  void recv_prepare_cql_query(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, prepare_cql_query_shared_promise_t promise);
+  execute_prepared_cql_query_shared_future_t execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values);
+  void send_execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values);
+  void recv_execute_prepared_cql_query(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, execute_prepared_cql_query_shared_promise_t promise);
+  set_cql_version_shared_future_t set_cql_version(const std::string& version);
+  void send_set_cql_version(const std::string& version);
+  void recv_set_cql_version(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, std::string fname, apache::thrift::protocol::TMessageType mtype, set_cql_version_shared_promise_t promise);
+  bool abort(int32_t request_id) {
+  apache::thrift::concurrency::Guard g(mutex_);
+    return requests_.erase(request_id) != 0;
+  }
+  bool process(boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, void* connectionContext);
+ protected:
+  boost::shared_ptr<apache::thrift::transport::TTransport> potransport_;
+  boost::shared_ptr<apache::thrift::protocol::TProtocolFactory> poprotfact_;
+  apache::thrift::transport::TTransport* otransport_;
+  apache::thrift::protocol::TProtocolFactory* oprotfact_;
+  typedef std::map<int32_t, boost::function<void (boost::shared_ptr<apache::thrift::protocol::TProtocol> prot, std::string fname, apache::thrift::protocol::TMessageType mtype)> > request_map_t;
+  request_map_t requests_;
+  int32_t request_counter_;
+  apache::thrift::concurrency::Mutex mutex_;};
+
+class CassandraAsyncProcessor : virtual public apache::thrift::TProcessor {
+ protected:
+  boost::shared_ptr<CassandraAsyncIf> iface_;
+  virtual bool process_fn(boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string& fname, int32_t seqid);
+ private:
+  std::map<std::string, void (CassandraAsyncProcessor::*)(int32_t, boost::shared_ptr<apache::thrift::protocol::TProtocol>, boost::shared_ptr<apache::thrift::protocol::TProtocol>)> processMap_;
+  void process_login(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_login(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_login(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_login_result result);
+  void process_set_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_set_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_set_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_set_keyspace_result result);
+  void process_get(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_get(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, ColumnOrSuperColumn value);
+  void reply_get(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_result result);
+  void process_get_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_get_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<ColumnOrSuperColumn>  value);
+  void reply_get_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_slice_result result);
+  void process_get_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_get_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, int32_t value);
+  void reply_get_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_count_result result);
+  void process_multiget_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_multiget_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, std::vector<ColumnOrSuperColumn> >  value);
+  void reply_multiget_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_multiget_slice_result result);
+  void process_multiget_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_multiget_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, int32_t>  value);
+  void reply_multiget_count(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_multiget_count_result result);
+  void process_get_range_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_get_range_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KeySlice>  value);
+  void reply_get_range_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_range_slices_result result);
+  void process_get_paged_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_get_paged_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KeySlice>  value);
+  void reply_get_paged_slice(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_paged_slice_result result);
+  void process_get_indexed_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_get_indexed_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KeySlice>  value);
+  void reply_get_indexed_slices(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_get_indexed_slices_result result);
+  void process_insert(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_insert(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_insert(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_insert_result result);
+  void process_add(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_add(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_add(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_add_result result);
+  void process_remove(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_remove(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_remove(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_remove_result result);
+  void process_remove_counter(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_remove_counter(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_remove_counter(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_remove_counter_result result);
+  void process_batch_mutate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_batch_mutate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_batch_mutate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_batch_mutate_result result);
+  void process_truncate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_truncate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_truncate(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_truncate_result result);
+  void process_describe_schema_versions(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_schema_versions(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, std::vector<std::string> >  value);
+  void reply_describe_schema_versions(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_schema_versions_result result);
+  void process_describe_keyspaces(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_keyspaces(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<KsDef>  value);
+  void reply_describe_keyspaces(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_keyspaces_result result);
+  void process_describe_cluster_name(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_cluster_name(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_describe_cluster_name(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_cluster_name_result result);
+  void process_describe_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_describe_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_version_result result);
+  void process_describe_ring(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_ring(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<TokenRange>  value);
+  void reply_describe_ring(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_ring_result result);
+  void process_describe_token_map(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_token_map(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::map<std::string, std::string>  value);
+  void reply_describe_token_map(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_token_map_result result);
+  void process_describe_partitioner(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_partitioner(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_describe_partitioner(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_partitioner_result result);
+  void process_describe_snitch(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_snitch(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_describe_snitch(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_snitch_result result);
+  void process_describe_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, KsDef value);
+  void reply_describe_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_keyspace_result result);
+  void process_describe_splits(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_describe_splits(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::vector<std::string>  value);
+  void reply_describe_splits(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_describe_splits_result result);
+  void process_system_add_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_system_add_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_system_add_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_add_column_family_result result);
+  void process_system_drop_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_system_drop_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_system_drop_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_drop_column_family_result result);
+  void process_system_add_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_system_add_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_system_add_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_add_keyspace_result result);
+  void process_system_drop_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_system_drop_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_system_drop_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_drop_keyspace_result result);
+  void process_system_update_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_system_update_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_system_update_keyspace(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_update_keyspace_result result);
+  void process_system_update_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_system_update_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, std::string value);
+  void reply_system_update_column_family(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_system_update_column_family_result result);
+  void process_execute_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_execute_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, CqlResult value);
+  void reply_execute_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_execute_cql_query_result result);
+  void process_prepare_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_prepare_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, CqlPreparedResult value);
+  void reply_prepare_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_prepare_cql_query_result result);
+  void process_execute_prepared_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_execute_prepared_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, CqlResult value);
+  void reply_execute_prepared_cql_query(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_execute_prepared_cql_query_result result);
+  void process_set_cql_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void success_set_cql_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot);
+  void reply_set_cql_version(int32_t seqid, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, Cassandra_set_cql_version_result result);
+ public:
+  CassandraAsyncProcessor(boost::shared_ptr<CassandraAsyncIf> iface) :
+    iface_(iface) {
+    processMap_["login"] = &CassandraAsyncProcessor::process_login;
+    processMap_["set_keyspace"] = &CassandraAsyncProcessor::process_set_keyspace;
+    processMap_["get"] = &CassandraAsyncProcessor::process_get;
+    processMap_["get_slice"] = &CassandraAsyncProcessor::process_get_slice;
+    processMap_["get_count"] = &CassandraAsyncProcessor::process_get_count;
+    processMap_["multiget_slice"] = &CassandraAsyncProcessor::process_multiget_slice;
+    processMap_["multiget_count"] = &CassandraAsyncProcessor::process_multiget_count;
+    processMap_["get_range_slices"] = &CassandraAsyncProcessor::process_get_range_slices;
+    processMap_["get_paged_slice"] = &CassandraAsyncProcessor::process_get_paged_slice;
+    processMap_["get_indexed_slices"] = &CassandraAsyncProcessor::process_get_indexed_slices;
+    processMap_["insert"] = &CassandraAsyncProcessor::process_insert;
+    processMap_["add"] = &CassandraAsyncProcessor::process_add;
+    processMap_["remove"] = &CassandraAsyncProcessor::process_remove;
+    processMap_["remove_counter"] = &CassandraAsyncProcessor::process_remove_counter;
+    processMap_["batch_mutate"] = &CassandraAsyncProcessor::process_batch_mutate;
+    processMap_["truncate"] = &CassandraAsyncProcessor::process_truncate;
+    processMap_["describe_schema_versions"] = &CassandraAsyncProcessor::process_describe_schema_versions;
+    processMap_["describe_keyspaces"] = &CassandraAsyncProcessor::process_describe_keyspaces;
+    processMap_["describe_cluster_name"] = &CassandraAsyncProcessor::process_describe_cluster_name;
+    processMap_["describe_version"] = &CassandraAsyncProcessor::process_describe_version;
+    processMap_["describe_ring"] = &CassandraAsyncProcessor::process_describe_ring;
+    processMap_["describe_token_map"] = &CassandraAsyncProcessor::process_describe_token_map;
+    processMap_["describe_partitioner"] = &CassandraAsyncProcessor::process_describe_partitioner;
+    processMap_["describe_snitch"] = &CassandraAsyncProcessor::process_describe_snitch;
+    processMap_["describe_keyspace"] = &CassandraAsyncProcessor::process_describe_keyspace;
+    processMap_["describe_splits"] = &CassandraAsyncProcessor::process_describe_splits;
+    processMap_["system_add_column_family"] = &CassandraAsyncProcessor::process_system_add_column_family;
+    processMap_["system_drop_column_family"] = &CassandraAsyncProcessor::process_system_drop_column_family;
+    processMap_["system_add_keyspace"] = &CassandraAsyncProcessor::process_system_add_keyspace;
+    processMap_["system_drop_keyspace"] = &CassandraAsyncProcessor::process_system_drop_keyspace;
+    processMap_["system_update_keyspace"] = &CassandraAsyncProcessor::process_system_update_keyspace;
+    processMap_["system_update_column_family"] = &CassandraAsyncProcessor::process_system_update_column_family;
+    processMap_["execute_cql_query"] = &CassandraAsyncProcessor::process_execute_cql_query;
+    processMap_["prepare_cql_query"] = &CassandraAsyncProcessor::process_prepare_cql_query;
+    processMap_["execute_prepared_cql_query"] = &CassandraAsyncProcessor::process_execute_prepared_cql_query;
+    processMap_["set_cql_version"] = &CassandraAsyncProcessor::process_set_cql_version;
+  }
+
+  virtual bool process(boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, void* connectionContext);
+  virtual ~CassandraAsyncProcessor() {}
+};
+
+}}} // namespace
+
+#endif

=== added file 'storage/cassandra/gen-cpp-async/Cassandra_server.skeleton.cpp'
--- a/storage/cassandra/gen-cpp-async/Cassandra_server.skeleton.cpp	1970-01-01 00:00:00 +0000
+++ b/storage/cassandra/gen-cpp-async/Cassandra_server.skeleton.cpp	2012-09-20 14:32:37 +0000
@@ -0,0 +1,219 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "Cassandra.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace  ::org::apache::cassandra;
+
+class CassandraHandler : virtual public CassandraIf {
+ public:
+  CassandraHandler() {
+    // Your initialization goes here
+  }
+
+  void login(const AuthenticationRequest& auth_request) {
+    // Your implementation goes here
+    printf("login\n");
+  }
+
+  void set_keyspace(const std::string& keyspace) {
+    // Your implementation goes here
+    printf("set_keyspace\n");
+  }
+
+  void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get\n");
+  }
+
+  void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_slice\n");
+  }
+
+  int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_count\n");
+  }
+
+  void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("multiget_slice\n");
+  }
+
+  void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("multiget_count\n");
+  }
+
+  void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_range_slices\n");
+  }
+
+  void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_paged_slice\n");
+  }
+
+  void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_indexed_slices\n");
+  }
+
+  void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("insert\n");
+  }
+
+  void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("add\n");
+  }
+
+  void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("remove\n");
+  }
+
+  void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("remove_counter\n");
+  }
+
+  void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("batch_mutate\n");
+  }
+
+  void truncate(const std::string& cfname) {
+    // Your implementation goes here
+    printf("truncate\n");
+  }
+
+  void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) {
+    // Your implementation goes here
+    printf("describe_schema_versions\n");
+  }
+
+  void describe_keyspaces(std::vector<KsDef> & _return) {
+    // Your implementation goes here
+    printf("describe_keyspaces\n");
+  }
+
+  void describe_cluster_name(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_cluster_name\n");
+  }
+
+  void describe_version(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_version\n");
+  }
+
+  void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) {
+    // Your implementation goes here
+    printf("describe_ring\n");
+  }
+
+  void describe_token_map(std::map<std::string, std::string> & _return) {
+    // Your implementation goes here
+    printf("describe_token_map\n");
+  }
+
+  void describe_partitioner(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_partitioner\n");
+  }
+
+  void describe_snitch(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_snitch\n");
+  }
+
+  void describe_keyspace(KsDef& _return, const std::string& keyspace) {
+    // Your implementation goes here
+    printf("describe_keyspace\n");
+  }
+
+  void describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) {
+    // Your implementation goes here
+    printf("describe_splits\n");
+  }
+
+  void system_add_column_family(std::string& _return, const CfDef& cf_def) {
+    // Your implementation goes here
+    printf("system_add_column_family\n");
+  }
+
+  void system_drop_column_family(std::string& _return, const std::string& column_family) {
+    // Your implementation goes here
+    printf("system_drop_column_family\n");
+  }
+
+  void system_add_keyspace(std::string& _return, const KsDef& ks_def) {
+    // Your implementation goes here
+    printf("system_add_keyspace\n");
+  }
+
+  void system_drop_keyspace(std::string& _return, const std::string& keyspace) {
+    // Your implementation goes here
+    printf("system_drop_keyspace\n");
+  }
+
+  void system_update_keyspace(std::string& _return, const KsDef& ks_def) {
+    // Your implementation goes here
+    printf("system_update_keyspace\n");
+  }
+
+  void system_update_column_family(std::string& _return, const CfDef& cf_def) {
+    // Your implementation goes here
+    printf("system_update_column_family\n");
+  }
+
+  void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) {
+    // Your implementation goes here
+    printf("execute_cql_query\n");
+  }
+
+  void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression) {
+    // Your implementation goes here
+    printf("prepare_cql_query\n");
+  }
+
+  void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values) {
+    // Your implementation goes here
+    printf("execute_prepared_cql_query\n");
+  }
+
+  void set_cql_version(const std::string& version) {
+    // Your implementation goes here
+    printf("set_cql_version\n");
+  }
+
+};
+
+int main(int argc, char **argv) {
+  int port = 9090;
+  shared_ptr<CassandraHandler> handler(new CassandraHandler());
+  shared_ptr<TProcessor> processor(new CassandraProcessor(handler));
+  shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+  shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+  shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+  TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+  server.serve();
+  return 0;
+}
+

=== added file 'storage/cassandra/gen-cpp-async/cassandra_constants.cpp'
--- a/storage/cassandra/gen-cpp-async/cassandra_constants.cpp	1970-01-01 00:00:00 +0000
+++ b/storage/cassandra/gen-cpp-async/cassandra_constants.cpp	2012-09-20 14:32:37 +0000
@@ -0,0 +1,21 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0-dev)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "cassandra_constants.h"
+
+namespace org { namespace apache { namespace cassandra {
+
+const cassandraConstants g_cassandra_constants;
+
+cassandraConstants::cassandraConstants() {
+  //psergey
+  //VERSION = "19.32.0";
+  cassandra_VERSION = "19.32.0";
+
+}
+
+}}} // namespace
+

=== added file 'storage/cassandra/gen-cpp-async/cassandra_constants.h'
--- a/storage/cassandra/gen-cpp-async/cassandra_constants.h	1970-01-01 00:00:00 +0000
+++ b/storage/cassandra/gen-cpp-async/cassandra_constants.h	2012-09-20 14:32:37 +0000
@@ -0,0 +1,27 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0-dev)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef cassandra_CONSTANTS_H
+#define cassandra_CONSTANTS_H
+
+#include "cassandra_types.h"
+
+namespace org { namespace apache { namespace cassandra {
+
+class cassandraConstants {
+ public:
+  cassandraConstants();
+
+  //psergey:
+  //std::string VERSION;
+  std::string cassandra_VERSION;
+};
+
+extern const cassandraConstants g_cassandra_constants;
+
+}}} // namespace
+
+#endif

=== added file 'storage/cassandra/gen-cpp-async/cassandra_types.cpp'
--- a/storage/cassandra/gen-cpp-async/cassandra_types.cpp	1970-01-01 00:00:00 +0000
+++ b/storage/cassandra/gen-cpp-async/cassandra_types.cpp	2012-09-20 14:32:37 +0000
@@ -0,0 +1,3866 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0-dev)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "cassandra_types.h"
+
+#include <algorithm>
+
+namespace org { namespace apache { namespace cassandra {
+
+int _kConsistencyLevelValues[] = {
+  ConsistencyLevel::ONE,
+  ConsistencyLevel::QUORUM,
+  ConsistencyLevel::LOCAL_QUORUM,
+  ConsistencyLevel::EACH_QUORUM,
+  ConsistencyLevel::ALL,
+  ConsistencyLevel::ANY,
+  ConsistencyLevel::TWO,
+  ConsistencyLevel::THREE
+};
+const char* _kConsistencyLevelNames[] = {
+  "ONE",
+  "QUORUM",
+  "LOCAL_QUORUM",
+  "EACH_QUORUM",
+  "ALL",
+  "ANY",
+  "TWO",
+  "THREE"
+};
+const std::map<int, const char*> _ConsistencyLevel_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kConsistencyLevelValues, _kConsistencyLevelNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kIndexOperatorValues[] = {
+  IndexOperator::EQ,
+  IndexOperator::GTE,
+  IndexOperator::GT,
+  IndexOperator::LTE,
+  IndexOperator::LT
+};
+const char* _kIndexOperatorNames[] = {
+  "EQ",
+  "GTE",
+  "GT",
+  "LTE",
+  "LT"
+};
+const std::map<int, const char*> _IndexOperator_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kIndexOperatorValues, _kIndexOperatorNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kIndexTypeValues[] = {
+  IndexType::KEYS,
+  IndexType::CUSTOM
+};
+const char* _kIndexTypeNames[] = {
+  "KEYS",
+  "CUSTOM"
+};
+const std::map<int, const char*> _IndexType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kIndexTypeValues, _kIndexTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kCompressionValues[] = {
+  Compression::GZIP,
+  Compression::NONE
+};
+const char* _kCompressionNames[] = {
+  "GZIP",
+  "NONE"
+};
+const std::map<int, const char*> _Compression_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kCompressionValues, _kCompressionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kCqlResultTypeValues[] = {
+  CqlResultType::ROWS,
+  CqlResultType::VOID,
+  CqlResultType::INT
+};
+const char* _kCqlResultTypeNames[] = {
+  "ROWS",
+  "VOID",
+  "INT"
+};
+const std::map<int, const char*> _CqlResultType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kCqlResultTypeValues, _kCqlResultTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+const char* Column::ascii_fingerprint = "3EE0E1C5C844001B62F08125068292CC";
+const uint8_t Column::binary_fingerprint[16] = {0x3E,0xE0,0xE1,0xC5,0xC8,0x44,0x00,0x1B,0x62,0xF0,0x81,0x25,0x06,0x82,0x92,0xCC};
+
+uint32_t Column::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_name = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->timestamp);
+          this->__isset.timestamp = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->ttl);
+          this->__isset.ttl = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Column");
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeBinary(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.timestamp) {
+    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
+    xfer += oprot->writeI64(this->timestamp);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.ttl) {
+    xfer += oprot->writeFieldBegin("ttl", ::apache::thrift::protocol::T_I32, 4);
+    xfer += oprot->writeI32(this->ttl);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Column &a, Column &b) {
+  using ::std::swap;
+  swap(a.name, b.name);
+  swap(a.value, b.value);
+  swap(a.timestamp, b.timestamp);
+  swap(a.ttl, b.ttl);
+  swap(a.__isset, b.__isset);
+}
+
+const char* SuperColumn::ascii_fingerprint = "470EFC558004E98D92D604898305C04E";
+const uint8_t SuperColumn::binary_fingerprint[16] = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
+
+uint32_t SuperColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_name = false;
+  bool isset_columns = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->columns.clear();
+            uint32_t _size0;
+            ::apache::thrift::protocol::TType _etype3;
+            xfer += iprot->readListBegin(_etype3, _size0);
+            this->columns.resize(_size0);
+            uint32_t _i4;
+            for (_i4 = 0; _i4 < _size0; ++_i4)
+            {
+              xfer += this->columns[_i4].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_columns = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_columns)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t SuperColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("SuperColumn");
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
+    std::vector<Column> ::const_iterator _iter5;
+    for (_iter5 = this->columns.begin(); _iter5 != this->columns.end(); ++_iter5)
+    {
+      xfer += (*_iter5).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SuperColumn &a, SuperColumn &b) {
+  using ::std::swap;
+  swap(a.name, b.name);
+  swap(a.columns, b.columns);
+}
+
+const char* CounterColumn::ascii_fingerprint = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
+const uint8_t CounterColumn::binary_fingerprint[16] = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};
+
+uint32_t CounterColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_name = false;
+  bool isset_value = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->value);
+          isset_value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_value)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t CounterColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("CounterColumn");
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 2);
+  xfer += oprot->writeI64(this->value);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(CounterColumn &a, CounterColumn &b) {
+  using ::std::swap;
+  swap(a.name, b.name);
+  swap(a.value, b.value);
+}
+
+const char* CounterSuperColumn::ascii_fingerprint = "CD4C8C4BF7753E46DE417CDE369343A4";
+const uint8_t CounterSuperColumn::binary_fingerprint[16] = {0xCD,0x4C,0x8C,0x4B,0xF7,0x75,0x3E,0x46,0xDE,0x41,0x7C,0xDE,0x36,0x93,0x43,0xA4};
+
+uint32_t CounterSuperColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_name = false;
+  bool isset_columns = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->columns.clear();
+            uint32_t _size6;
+            ::apache::thrift::protocol::TType _etype9;
+            xfer += iprot->readListBegin(_etype9, _size6);
+            this->columns.resize(_size6);
+            uint32_t _i10;
+            for (_i10 = 0; _i10 < _size6; ++_i10)
+            {
+              xfer += this->columns[_i10].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_columns = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_columns)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t CounterSuperColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("CounterSuperColumn");
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
+    std::vector<CounterColumn> ::const_iterator _iter11;
+    for (_iter11 = this->columns.begin(); _iter11 != this->columns.end(); ++_iter11)
+    {
+      xfer += (*_iter11).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(CounterSuperColumn &a, CounterSuperColumn &b) {
+  using ::std::swap;
+  swap(a.name, b.name);
+  swap(a.columns, b.columns);
+}
+
+const char* ColumnOrSuperColumn::ascii_fingerprint = "2B34AC9E80F1DAA3A2A63B1AB1841E61";
+const uint8_t ColumnOrSuperColumn::binary_fingerprint[16] = {0x2B,0x34,0xAC,0x9E,0x80,0xF1,0xDA,0xA3,0xA2,0xA6,0x3B,0x1A,0xB1,0x84,0x1E,0x61};
+
+uint32_t ColumnOrSuperColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column.read(iprot);
+          this->__isset.column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->super_column.read(iprot);
+          this->__isset.super_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->counter_column.read(iprot);
+          this->__isset.counter_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->counter_super_column.read(iprot);
+          this->__isset.counter_super_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t ColumnOrSuperColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ColumnOrSuperColumn");
+
+  if (this->__isset.column) {
+    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->column.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.super_column) {
+    xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->super_column.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.counter_column) {
+    xfer += oprot->writeFieldBegin("counter_column", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->counter_column.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.counter_super_column) {
+    xfer += oprot->writeFieldBegin("counter_super_column", ::apache::thrift::protocol::T_STRUCT, 4);
+    xfer += this->counter_super_column.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ColumnOrSuperColumn &a, ColumnOrSuperColumn &b) {
+  using ::std::swap;
+  swap(a.column, b.column);
+  swap(a.super_column, b.super_column);
+  swap(a.counter_column, b.counter_column);
+  swap(a.counter_super_column, b.counter_super_column);
+  swap(a.__isset, b.__isset);
+}
+
+const char* NotFoundException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t NotFoundException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t NotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NotFoundException");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(NotFoundException &a, NotFoundException &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+const char* InvalidRequestException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t InvalidRequestException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t InvalidRequestException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_why = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->why);
+          isset_why = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_why)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t InvalidRequestException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("InvalidRequestException");
+
+  xfer += oprot->writeFieldBegin("why", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->why);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(InvalidRequestException &a, InvalidRequestException &b) {
+  using ::std::swap;
+  swap(a.why, b.why);
+}
+
+const char* UnavailableException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t UnavailableException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t UnavailableException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t UnavailableException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("UnavailableException");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(UnavailableException &a, UnavailableException &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+const char* TimedOutException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t TimedOutException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t TimedOutException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t TimedOutException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("TimedOutException");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TimedOutException &a, TimedOutException &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+const char* AuthenticationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t AuthenticationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t AuthenticationException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_why = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->why);
+          isset_why = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_why)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t AuthenticationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("AuthenticationException");
+
+  xfer += oprot->writeFieldBegin("why", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->why);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(AuthenticationException &a, AuthenticationException &b) {
+  using ::std::swap;
+  swap(a.why, b.why);
+}
+
+const char* AuthorizationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t AuthorizationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t AuthorizationException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_why = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->why);
+          isset_why = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_why)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t AuthorizationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("AuthorizationException");
+
+  xfer += oprot->writeFieldBegin("why", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->why);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(AuthorizationException &a, AuthorizationException &b) {
+  using ::std::swap;
+  swap(a.why, b.why);
+}
+
+const char* SchemaDisagreementException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t SchemaDisagreementException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t SchemaDisagreementException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t SchemaDisagreementException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("SchemaDisagreementException");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SchemaDisagreementException &a, SchemaDisagreementException &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+const char* ColumnParent::ascii_fingerprint = "0A13AE61181713A4100DFFB3EC293822";
+const uint8_t ColumnParent::binary_fingerprint[16] = {0x0A,0x13,0xAE,0x61,0x18,0x17,0x13,0xA4,0x10,0x0D,0xFF,0xB3,0xEC,0x29,0x38,0x22};
+
+uint32_t ColumnParent::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_column_family = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->column_family);
+          isset_column_family = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->super_column);
+          this->__isset.super_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_column_family)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ColumnParent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ColumnParent");
+
+  xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->column_family);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.super_column) {
+    xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeBinary(this->super_column);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ColumnParent &a, ColumnParent &b) {
+  using ::std::swap;
+  swap(a.column_family, b.column_family);
+  swap(a.super_column, b.super_column);
+  swap(a.__isset, b.__isset);
+}
+
+const char* ColumnPath::ascii_fingerprint = "606212895BCF63C757913CF35AEB3462";
+const uint8_t ColumnPath::binary_fingerprint[16] = {0x60,0x62,0x12,0x89,0x5B,0xCF,0x63,0xC7,0x57,0x91,0x3C,0xF3,0x5A,0xEB,0x34,0x62};
+
+uint32_t ColumnPath::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_column_family = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->column_family);
+          isset_column_family = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->super_column);
+          this->__isset.super_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->column);
+          this->__isset.column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_column_family)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ColumnPath::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ColumnPath");
+
+  xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->column_family);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.super_column) {
+    xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeBinary(this->super_column);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.column) {
+    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 5);
+    xfer += oprot->writeBinary(this->column);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ColumnPath &a, ColumnPath &b) {
+  using ::std::swap;
+  swap(a.column_family, b.column_family);
+  swap(a.super_column, b.super_column);
+  swap(a.column, b.column);
+  swap(a.__isset, b.__isset);
+}
+
+const char* SliceRange::ascii_fingerprint = "184D24C9A0B8D4415E234DB649CAE740";
+const uint8_t SliceRange::binary_fingerprint[16] = {0x18,0x4D,0x24,0xC9,0xA0,0xB8,0xD4,0x41,0x5E,0x23,0x4D,0xB6,0x49,0xCA,0xE7,0x40};
+
+uint32_t SliceRange::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_start = false;
+  bool isset_finish = false;
+  bool isset_reversed = false;
+  bool isset_count = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->start);
+          isset_start = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->finish);
+          isset_finish = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->reversed);
+          isset_reversed = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->count);
+          isset_count = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_start)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_finish)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_reversed)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_count)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t SliceRange::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("SliceRange");
+
+  xfer += oprot->writeFieldBegin("start", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->start);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("finish", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->finish);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("reversed", ::apache::thrift::protocol::T_BOOL, 3);
+  xfer += oprot->writeBool(this->reversed);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32(this->count);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SliceRange &a, SliceRange &b) {
+  using ::std::swap;
+  swap(a.start, b.start);
+  swap(a.finish, b.finish);
+  swap(a.reversed, b.reversed);
+  swap(a.count, b.count);
+}
+
+const char* SlicePredicate::ascii_fingerprint = "F59D1D81C17DFFAF09988BF1C9CE5E27";
+const uint8_t SlicePredicate::binary_fingerprint[16] = {0xF5,0x9D,0x1D,0x81,0xC1,0x7D,0xFF,0xAF,0x09,0x98,0x8B,0xF1,0xC9,0xCE,0x5E,0x27};
+
+uint32_t SlicePredicate::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->column_names.clear();
+            uint32_t _size12;
+            ::apache::thrift::protocol::TType _etype15;
+            xfer += iprot->readListBegin(_etype15, _size12);
+            this->column_names.resize(_size12);
+            uint32_t _i16;
+            for (_i16 = 0; _i16 < _size12; ++_i16)
+            {
+              xfer += iprot->readBinary(this->column_names[_i16]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.column_names = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->slice_range.read(iprot);
+          this->__isset.slice_range = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t SlicePredicate::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("SlicePredicate");
+
+  if (this->__isset.column_names) {
+    xfer += oprot->writeFieldBegin("column_names", ::apache::thrift::protocol::T_LIST, 1);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->column_names.size()));
+      std::vector<std::string> ::const_iterator _iter17;
+      for (_iter17 = this->column_names.begin(); _iter17 != this->column_names.end(); ++_iter17)
+      {
+        xfer += oprot->writeBinary((*_iter17));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.slice_range) {
+    xfer += oprot->writeFieldBegin("slice_range", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->slice_range.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SlicePredicate &a, SlicePredicate &b) {
+  using ::std::swap;
+  swap(a.column_names, b.column_names);
+  swap(a.slice_range, b.slice_range);
+  swap(a.__isset, b.__isset);
+}
+
+const char* IndexExpression::ascii_fingerprint = "D9F4CFE2F293A8B1052FD3031DD2C847";
+const uint8_t IndexExpression::binary_fingerprint[16] = {0xD9,0xF4,0xCF,0xE2,0xF2,0x93,0xA8,0xB1,0x05,0x2F,0xD3,0x03,0x1D,0xD2,0xC8,0x47};
+
+uint32_t IndexExpression::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_column_name = false;
+  bool isset_op = false;
+  bool isset_value = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->column_name);
+          isset_column_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast18;
+          xfer += iprot->readI32(ecast18);
+          this->op = (IndexOperator::type)ecast18;
+          isset_op = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->value);
+          isset_value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_column_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_op)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_value)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t IndexExpression::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("IndexExpression");
+
+  xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->column_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("op", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->op);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeBinary(this->value);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(IndexExpression &a, IndexExpression &b) {
+  using ::std::swap;
+  swap(a.column_name, b.column_name);
+  swap(a.op, b.op);
+  swap(a.value, b.value);
+}
+
+const char* IndexClause::ascii_fingerprint = "9B551B9AB86120B0EEA9005C77FD3C1F";
+const uint8_t IndexClause::binary_fingerprint[16] = {0x9B,0x55,0x1B,0x9A,0xB8,0x61,0x20,0xB0,0xEE,0xA9,0x00,0x5C,0x77,0xFD,0x3C,0x1F};
+
+uint32_t IndexClause::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_expressions = false;
+  bool isset_start_key = false;
+  bool isset_count = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->expressions.clear();
+            uint32_t _size19;
+            ::apache::thrift::protocol::TType _etype22;
+            xfer += iprot->readListBegin(_etype22, _size19);
+            this->expressions.resize(_size19);
+            uint32_t _i23;
+            for (_i23 = 0; _i23 < _size19; ++_i23)
+            {
+              xfer += this->expressions[_i23].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_expressions = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->start_key);
+          isset_start_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->count);
+          isset_count = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_expressions)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_start_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_count)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t IndexClause::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("IndexClause");
+
+  xfer += oprot->writeFieldBegin("expressions", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->expressions.size()));
+    std::vector<IndexExpression> ::const_iterator _iter24;
+    for (_iter24 = this->expressions.begin(); _iter24 != this->expressions.end(); ++_iter24)
+    {
+      xfer += (*_iter24).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("start_key", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->start_key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32(this->count);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(IndexClause &a, IndexClause &b) {
+  using ::std::swap;
+  swap(a.expressions, b.expressions);
+  swap(a.start_key, b.start_key);
+  swap(a.count, b.count);
+}
+
+const char* KeyRange::ascii_fingerprint = "A6EC82FA0980B91C7C8EB013C61CA1B0";
+const uint8_t KeyRange::binary_fingerprint[16] = {0xA6,0xEC,0x82,0xFA,0x09,0x80,0xB9,0x1C,0x7C,0x8E,0xB0,0x13,0xC6,0x1C,0xA1,0xB0};
+
+uint32_t KeyRange::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_count = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->start_key);
+          this->__isset.start_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->end_key);
+          this->__isset.end_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->start_token);
+          this->__isset.start_token = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->end_token);
+          this->__isset.end_token = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->row_filter.clear();
+            uint32_t _size25;
+            ::apache::thrift::protocol::TType _etype28;
+            xfer += iprot->readListBegin(_etype28, _size25);
+            this->row_filter.resize(_size25);
+            uint32_t _i29;
+            for (_i29 = 0; _i29 < _size25; ++_i29)
+            {
+              xfer += this->row_filter[_i29].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.row_filter = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->count);
+          isset_count = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_count)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t KeyRange::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("KeyRange");
+
+  if (this->__isset.start_key) {
+    xfer += oprot->writeFieldBegin("start_key", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeBinary(this->start_key);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.end_key) {
+    xfer += oprot->writeFieldBegin("end_key", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeBinary(this->end_key);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.start_token) {
+    xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->start_token);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.end_token) {
+    xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->end_token);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 5);
+  xfer += oprot->writeI32(this->count);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.row_filter) {
+    xfer += oprot->writeFieldBegin("row_filter", ::apache::thrift::protocol::T_LIST, 6);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_filter.size()));
+      std::vector<IndexExpression> ::const_iterator _iter30;
+      for (_iter30 = this->row_filter.begin(); _iter30 != this->row_filter.end(); ++_iter30)
+      {
+        xfer += (*_iter30).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(KeyRange &a, KeyRange &b) {
+  using ::std::swap;
+  swap(a.start_key, b.start_key);
+  swap(a.end_key, b.end_key);
+  swap(a.start_token, b.start_token);
+  swap(a.end_token, b.end_token);
+  swap(a.row_filter, b.row_filter);
+  swap(a.count, b.count);
+  swap(a.__isset, b.__isset);
+}
+
+const char* KeySlice::ascii_fingerprint = "D1568675B0C135C909E3169B72A4DA3D";
+const uint8_t KeySlice::binary_fingerprint[16] = {0xD1,0x56,0x86,0x75,0xB0,0xC1,0x35,0xC9,0x09,0xE3,0x16,0x9B,0x72,0xA4,0xDA,0x3D};
+
+uint32_t KeySlice::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_columns = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->columns.clear();
+            uint32_t _size31;
+            ::apache::thrift::protocol::TType _etype34;
+            xfer += iprot->readListBegin(_etype34, _size31);
+            this->columns.resize(_size31);
+            uint32_t _i35;
+            for (_i35 = 0; _i35 < _size31; ++_i35)
+            {
+              xfer += this->columns[_i35].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_columns = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_columns)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t KeySlice::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("KeySlice");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
+    std::vector<ColumnOrSuperColumn> ::const_iterator _iter36;
+    for (_iter36 = this->columns.begin(); _iter36 != this->columns.end(); ++_iter36)
+    {
+      xfer += (*_iter36).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(KeySlice &a, KeySlice &b) {
+  using ::std::swap;
+  swap(a.key, b.key);
+  swap(a.columns, b.columns);
+}
+
+const char* KeyCount::ascii_fingerprint = "EEBC915CE44901401D881E6091423036";
+const uint8_t KeyCount::binary_fingerprint[16] = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
+
+uint32_t KeyCount::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_count = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->count);
+          isset_count = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_count)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t KeyCount::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("KeyCount");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32(this->count);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(KeyCount &a, KeyCount &b) {
+  using ::std::swap;
+  swap(a.key, b.key);
+  swap(a.count, b.count);
+}
+
+const char* Deletion::ascii_fingerprint = "40F33ECF1C932CA77C2414C4E6C60CBE";
+const uint8_t Deletion::binary_fingerprint[16] = {0x40,0xF3,0x3E,0xCF,0x1C,0x93,0x2C,0xA7,0x7C,0x24,0x14,0xC4,0xE6,0xC6,0x0C,0xBE};
+
+uint32_t Deletion::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->timestamp);
+          this->__isset.timestamp = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->super_column);
+          this->__isset.super_column = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->predicate.read(iprot);
+          this->__isset.predicate = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Deletion::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Deletion");
+
+  if (this->__isset.timestamp) {
+    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 1);
+    xfer += oprot->writeI64(this->timestamp);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.super_column) {
+    xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeBinary(this->super_column);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.predicate) {
+    xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->predicate.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Deletion &a, Deletion &b) {
+  using ::std::swap;
+  swap(a.timestamp, b.timestamp);
+  swap(a.super_column, b.super_column);
+  swap(a.predicate, b.predicate);
+  swap(a.__isset, b.__isset);
+}
+
+const char* Mutation::ascii_fingerprint = "E8B65DF3979C6868F80DF81F8E769E63";
+const uint8_t Mutation::binary_fingerprint[16] = {0xE8,0xB6,0x5D,0xF3,0x97,0x9C,0x68,0x68,0xF8,0x0D,0xF8,0x1F,0x8E,0x76,0x9E,0x63};
+
+uint32_t Mutation::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->column_or_supercolumn.read(iprot);
+          this->__isset.column_or_supercolumn = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->deletion.read(iprot);
+          this->__isset.deletion = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Mutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Mutation");
+
+  if (this->__isset.column_or_supercolumn) {
+    xfer += oprot->writeFieldBegin("column_or_supercolumn", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->column_or_supercolumn.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.deletion) {
+    xfer += oprot->writeFieldBegin("deletion", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->deletion.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Mutation &a, Mutation &b) {
+  using ::std::swap;
+  swap(a.column_or_supercolumn, b.column_or_supercolumn);
+  swap(a.deletion, b.deletion);
+  swap(a.__isset, b.__isset);
+}
+
+const char* EndpointDetails::ascii_fingerprint = "F4A50F0EC638C7F66026F9B6678FD89B";
+const uint8_t EndpointDetails::binary_fingerprint[16] = {0xF4,0xA5,0x0F,0x0E,0xC6,0x38,0xC7,0xF6,0x60,0x26,0xF9,0xB6,0x67,0x8F,0xD8,0x9B};
+
+uint32_t EndpointDetails::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->host);
+          this->__isset.host = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->datacenter);
+          this->__isset.datacenter = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->rack);
+          this->__isset.rack = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t EndpointDetails::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("EndpointDetails");
+
+  xfer += oprot->writeFieldBegin("host", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->host);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("datacenter", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->datacenter);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.rack) {
+    xfer += oprot->writeFieldBegin("rack", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->rack);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(EndpointDetails &a, EndpointDetails &b) {
+  using ::std::swap;
+  swap(a.host, b.host);
+  swap(a.datacenter, b.datacenter);
+  swap(a.rack, b.rack);
+  swap(a.__isset, b.__isset);
+}
+
+const char* TokenRange::ascii_fingerprint = "832268DC4CD6B17EE8881FC57EA04679";
+const uint8_t TokenRange::binary_fingerprint[16] = {0x83,0x22,0x68,0xDC,0x4C,0xD6,0xB1,0x7E,0xE8,0x88,0x1F,0xC5,0x7E,0xA0,0x46,0x79};
+
+uint32_t TokenRange::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_start_token = false;
+  bool isset_end_token = false;
+  bool isset_endpoints = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->start_token);
+          isset_start_token = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->end_token);
+          isset_end_token = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->endpoints.clear();
+            uint32_t _size37;
+            ::apache::thrift::protocol::TType _etype40;
+            xfer += iprot->readListBegin(_etype40, _size37);
+            this->endpoints.resize(_size37);
+            uint32_t _i41;
+            for (_i41 = 0; _i41 < _size37; ++_i41)
+            {
+              xfer += iprot->readString(this->endpoints[_i41]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_endpoints = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->rpc_endpoints.clear();
+            uint32_t _size42;
+            ::apache::thrift::protocol::TType _etype45;
+            xfer += iprot->readListBegin(_etype45, _size42);
+            this->rpc_endpoints.resize(_size42);
+            uint32_t _i46;
+            for (_i46 = 0; _i46 < _size42; ++_i46)
+            {
+              xfer += iprot->readString(this->rpc_endpoints[_i46]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.rpc_endpoints = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->endpoint_details.clear();
+            uint32_t _size47;
+            ::apache::thrift::protocol::TType _etype50;
+            xfer += iprot->readListBegin(_etype50, _size47);
+            this->endpoint_details.resize(_size47);
+            uint32_t _i51;
+            for (_i51 = 0; _i51 < _size47; ++_i51)
+            {
+              xfer += this->endpoint_details[_i51].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.endpoint_details = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_start_token)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_end_token)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_endpoints)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TokenRange::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("TokenRange");
+
+  xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->start_token);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->end_token);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("endpoints", ::apache::thrift::protocol::T_LIST, 3);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->endpoints.size()));
+    std::vector<std::string> ::const_iterator _iter52;
+    for (_iter52 = this->endpoints.begin(); _iter52 != this->endpoints.end(); ++_iter52)
+    {
+      xfer += oprot->writeString((*_iter52));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.rpc_endpoints) {
+    xfer += oprot->writeFieldBegin("rpc_endpoints", ::apache::thrift::protocol::T_LIST, 4);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rpc_endpoints.size()));
+      std::vector<std::string> ::const_iterator _iter53;
+      for (_iter53 = this->rpc_endpoints.begin(); _iter53 != this->rpc_endpoints.end(); ++_iter53)
+      {
+        xfer += oprot->writeString((*_iter53));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.endpoint_details) {
+    xfer += oprot->writeFieldBegin("endpoint_details", ::apache::thrift::protocol::T_LIST, 5);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->endpoint_details.size()));
+      std::vector<EndpointDetails> ::const_iterator _iter54;
+      for (_iter54 = this->endpoint_details.begin(); _iter54 != this->endpoint_details.end(); ++_iter54)
+      {
+        xfer += (*_iter54).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TokenRange &a, TokenRange &b) {
+  using ::std::swap;
+  swap(a.start_token, b.start_token);
+  swap(a.end_token, b.end_token);
+  swap(a.endpoints, b.endpoints);
+  swap(a.rpc_endpoints, b.rpc_endpoints);
+  swap(a.endpoint_details, b.endpoint_details);
+  swap(a.__isset, b.__isset);
+}
+
+const char* AuthenticationRequest::ascii_fingerprint = "5EA2D527ECA3BA20C77AFC023EE8C05F";
+const uint8_t AuthenticationRequest::binary_fingerprint[16] = {0x5E,0xA2,0xD5,0x27,0xEC,0xA3,0xBA,0x20,0xC7,0x7A,0xFC,0x02,0x3E,0xE8,0xC0,0x5F};
+
+uint32_t AuthenticationRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_credentials = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->credentials.clear();
+            uint32_t _size55;
+            ::apache::thrift::protocol::TType _ktype56;
+            ::apache::thrift::protocol::TType _vtype57;
+            xfer += iprot->readMapBegin(_ktype56, _vtype57, _size55);
+            uint32_t _i59;
+            for (_i59 = 0; _i59 < _size55; ++_i59)
+            {
+              std::string _key60;
+              xfer += iprot->readString(_key60);
+              std::string& _val61 = this->credentials[_key60];
+              xfer += iprot->readString(_val61);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_credentials = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_credentials)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t AuthenticationRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("AuthenticationRequest");
+
+  xfer += oprot->writeFieldBegin("credentials", ::apache::thrift::protocol::T_MAP, 1);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->credentials.size()));
+    std::map<std::string, std::string> ::const_iterator _iter62;
+    for (_iter62 = this->credentials.begin(); _iter62 != this->credentials.end(); ++_iter62)
+    {
+      xfer += oprot->writeString(_iter62->first);
+      xfer += oprot->writeString(_iter62->second);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(AuthenticationRequest &a, AuthenticationRequest &b) {
+  using ::std::swap;
+  swap(a.credentials, b.credentials);
+}
+
+const char* ColumnDef::ascii_fingerprint = "0D89CE83D7EDAD079AC3213ED1DCAA58";
+const uint8_t ColumnDef::binary_fingerprint[16] = {0x0D,0x89,0xCE,0x83,0xD7,0xED,0xAD,0x07,0x9A,0xC3,0x21,0x3E,0xD1,0xDC,0xAA,0x58};
+
+uint32_t ColumnDef::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_name = false;
+  bool isset_validation_class = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->validation_class);
+          isset_validation_class = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast63;
+          xfer += iprot->readI32(ecast63);
+          this->index_type = (IndexType::type)ecast63;
+          this->__isset.index_type = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->index_name);
+          this->__isset.index_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->index_options.clear();
+            uint32_t _size64;
+            ::apache::thrift::protocol::TType _ktype65;
+            ::apache::thrift::protocol::TType _vtype66;
+            xfer += iprot->readMapBegin(_ktype65, _vtype66, _size64);
+            uint32_t _i68;
+            for (_i68 = 0; _i68 < _size64; ++_i68)
+            {
+              std::string _key69;
+              xfer += iprot->readString(_key69);
+              std::string& _val70 = this->index_options[_key69];
+              xfer += iprot->readString(_val70);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.index_options = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_validation_class)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ColumnDef::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ColumnDef");
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("validation_class", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->validation_class);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.index_type) {
+    xfer += oprot->writeFieldBegin("index_type", ::apache::thrift::protocol::T_I32, 3);
+    xfer += oprot->writeI32((int32_t)this->index_type);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.index_name) {
+    xfer += oprot->writeFieldBegin("index_name", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->index_name);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.index_options) {
+    xfer += oprot->writeFieldBegin("index_options", ::apache::thrift::protocol::T_MAP, 5);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->index_options.size()));
+      std::map<std::string, std::string> ::const_iterator _iter71;
+      for (_iter71 = this->index_options.begin(); _iter71 != this->index_options.end(); ++_iter71)
+      {
+        xfer += oprot->writeString(_iter71->first);
+        xfer += oprot->writeString(_iter71->second);
+      }
+      xfer += oprot->writeMapEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ColumnDef &a, ColumnDef &b) {
+  using ::std::swap;
+  swap(a.name, b.name);
+  swap(a.validation_class, b.validation_class);
+  swap(a.index_type, b.index_type);
+  swap(a.index_name, b.index_name);
+  swap(a.index_options, b.index_options);
+  swap(a.__isset, b.__isset);
+}
+
+const char* CfDef::ascii_fingerprint = "231A260521B5DD99EFBCCBDD8768CA7D";
+const uint8_t CfDef::binary_fingerprint[16] = {0x23,0x1A,0x26,0x05,0x21,0xB5,0xDD,0x99,0xEF,0xBC,0xCB,0xDD,0x87,0x68,0xCA,0x7D};
+
+uint32_t CfDef::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_keyspace = false;
+  bool isset_name = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->keyspace);
+          isset_keyspace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->column_type);
+          this->__isset.column_type = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->comparator_type);
+          this->__isset.comparator_type = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->subcomparator_type);
+          this->__isset.subcomparator_type = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->comment);
+          this->__isset.comment = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 12:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->read_repair_chance);
+          this->__isset.read_repair_chance = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 13:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->column_metadata.clear();
+            uint32_t _size72;
+            ::apache::thrift::protocol::TType _etype75;
+            xfer += iprot->readListBegin(_etype75, _size72);
+            this->column_metadata.resize(_size72);
+            uint32_t _i76;
+            for (_i76 = 0; _i76 < _size72; ++_i76)
+            {
+              xfer += this->column_metadata[_i76].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.column_metadata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 14:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->gc_grace_seconds);
+          this->__isset.gc_grace_seconds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 15:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->default_validation_class);
+          this->__isset.default_validation_class = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 16:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->id);
+          this->__isset.id = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 17:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->min_compaction_threshold);
+          this->__isset.min_compaction_threshold = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 18:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->max_compaction_threshold);
+          this->__isset.max_compaction_threshold = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 24:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->replicate_on_write);
+          this->__isset.replicate_on_write = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 26:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->key_validation_class);
+          this->__isset.key_validation_class = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 28:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->key_alias);
+          this->__isset.key_alias = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 29:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->compaction_strategy);
+          this->__isset.compaction_strategy = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 30:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->compaction_strategy_options.clear();
+            uint32_t _size77;
+            ::apache::thrift::protocol::TType _ktype78;
+            ::apache::thrift::protocol::TType _vtype79;
+            xfer += iprot->readMapBegin(_ktype78, _vtype79, _size77);
+            uint32_t _i81;
+            for (_i81 = 0; _i81 < _size77; ++_i81)
+            {
+              std::string _key82;
+              xfer += iprot->readString(_key82);
+              std::string& _val83 = this->compaction_strategy_options[_key82];
+              xfer += iprot->readString(_val83);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.compaction_strategy_options = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 32:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->compression_options.clear();
+            uint32_t _size84;
+            ::apache::thrift::protocol::TType _ktype85;
+            ::apache::thrift::protocol::TType _vtype86;
+            xfer += iprot->readMapBegin(_ktype85, _vtype86, _size84);
+            uint32_t _i88;
+            for (_i88 = 0; _i88 < _size84; ++_i88)
+            {
+              std::string _key89;
+              xfer += iprot->readString(_key89);
+              std::string& _val90 = this->compression_options[_key89];
+              xfer += iprot->readString(_val90);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.compression_options = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 33:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->bloom_filter_fp_chance);
+          this->__isset.bloom_filter_fp_chance = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 34:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->caching);
+          this->__isset.caching = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 37:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->dclocal_read_repair_chance);
+          this->__isset.dclocal_read_repair_chance = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->row_cache_size);
+          this->__isset.row_cache_size = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 11:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->key_cache_size);
+          this->__isset.key_cache_size = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 19:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->row_cache_save_period_in_seconds);
+          this->__isset.row_cache_save_period_in_seconds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 20:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->key_cache_save_period_in_seconds);
+          this->__isset.key_cache_save_period_in_seconds = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 21:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->memtable_flush_after_mins);
+          this->__isset.memtable_flush_after_mins = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 22:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->memtable_throughput_in_mb);
+          this->__isset.memtable_throughput_in_mb = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 23:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->memtable_operations_in_millions);
+          this->__isset.memtable_operations_in_millions = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 25:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->merge_shards_chance);
+          this->__isset.merge_shards_chance = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 27:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->row_cache_provider);
+          this->__isset.row_cache_provider = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 31:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->row_cache_keys_to_save);
+          this->__isset.row_cache_keys_to_save = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_keyspace)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t CfDef::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("CfDef");
+
+  xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->keyspace);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.column_type) {
+    xfer += oprot->writeFieldBegin("column_type", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->column_type);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.comparator_type) {
+    xfer += oprot->writeFieldBegin("comparator_type", ::apache::thrift::protocol::T_STRING, 5);
+    xfer += oprot->writeString(this->comparator_type);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.subcomparator_type) {
+    xfer += oprot->writeFieldBegin("subcomparator_type", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->subcomparator_type);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.comment) {
+    xfer += oprot->writeFieldBegin("comment", ::apache::thrift::protocol::T_STRING, 8);
+    xfer += oprot->writeString(this->comment);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.row_cache_size) {
+    xfer += oprot->writeFieldBegin("row_cache_size", ::apache::thrift::protocol::T_DOUBLE, 9);
+    xfer += oprot->writeDouble(this->row_cache_size);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.key_cache_size) {
+    xfer += oprot->writeFieldBegin("key_cache_size", ::apache::thrift::protocol::T_DOUBLE, 11);
+    xfer += oprot->writeDouble(this->key_cache_size);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.read_repair_chance) {
+    xfer += oprot->writeFieldBegin("read_repair_chance", ::apache::thrift::protocol::T_DOUBLE, 12);
+    xfer += oprot->writeDouble(this->read_repair_chance);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.column_metadata) {
+    xfer += oprot->writeFieldBegin("column_metadata", ::apache::thrift::protocol::T_LIST, 13);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_metadata.size()));
+      std::vector<ColumnDef> ::const_iterator _iter91;
+      for (_iter91 = this->column_metadata.begin(); _iter91 != this->column_metadata.end(); ++_iter91)
+      {
+        xfer += (*_iter91).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.gc_grace_seconds) {
+    xfer += oprot->writeFieldBegin("gc_grace_seconds", ::apache::thrift::protocol::T_I32, 14);
+    xfer += oprot->writeI32(this->gc_grace_seconds);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.default_validation_class) {
+    xfer += oprot->writeFieldBegin("default_validation_class", ::apache::thrift::protocol::T_STRING, 15);
+    xfer += oprot->writeString(this->default_validation_class);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.id) {
+    xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 16);
+    xfer += oprot->writeI32(this->id);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.min_compaction_threshold) {
+    xfer += oprot->writeFieldBegin("min_compaction_threshold", ::apache::thrift::protocol::T_I32, 17);
+    xfer += oprot->writeI32(this->min_compaction_threshold);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.max_compaction_threshold) {
+    xfer += oprot->writeFieldBegin("max_compaction_threshold", ::apache::thrift::protocol::T_I32, 18);
+    xfer += oprot->writeI32(this->max_compaction_threshold);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.row_cache_save_period_in_seconds) {
+    xfer += oprot->writeFieldBegin("row_cache_save_period_in_seconds", ::apache::thrift::protocol::T_I32, 19);
+    xfer += oprot->writeI32(this->row_cache_save_period_in_seconds);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.key_cache_save_period_in_seconds) {
+    xfer += oprot->writeFieldBegin("key_cache_save_period_in_seconds", ::apache::thrift::protocol::T_I32, 20);
+    xfer += oprot->writeI32(this->key_cache_save_period_in_seconds);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.memtable_flush_after_mins) {
+    xfer += oprot->writeFieldBegin("memtable_flush_after_mins", ::apache::thrift::protocol::T_I32, 21);
+    xfer += oprot->writeI32(this->memtable_flush_after_mins);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.memtable_throughput_in_mb) {
+    xfer += oprot->writeFieldBegin("memtable_throughput_in_mb", ::apache::thrift::protocol::T_I32, 22);
+    xfer += oprot->writeI32(this->memtable_throughput_in_mb);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.memtable_operations_in_millions) {
+    xfer += oprot->writeFieldBegin("memtable_operations_in_millions", ::apache::thrift::protocol::T_DOUBLE, 23);
+    xfer += oprot->writeDouble(this->memtable_operations_in_millions);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.replicate_on_write) {
+    xfer += oprot->writeFieldBegin("replicate_on_write", ::apache::thrift::protocol::T_BOOL, 24);
+    xfer += oprot->writeBool(this->replicate_on_write);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.merge_shards_chance) {
+    xfer += oprot->writeFieldBegin("merge_shards_chance", ::apache::thrift::protocol::T_DOUBLE, 25);
+    xfer += oprot->writeDouble(this->merge_shards_chance);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.key_validation_class) {
+    xfer += oprot->writeFieldBegin("key_validation_class", ::apache::thrift::protocol::T_STRING, 26);
+    xfer += oprot->writeString(this->key_validation_class);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.row_cache_provider) {
+    xfer += oprot->writeFieldBegin("row_cache_provider", ::apache::thrift::protocol::T_STRING, 27);
+    xfer += oprot->writeString(this->row_cache_provider);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.key_alias) {
+    xfer += oprot->writeFieldBegin("key_alias", ::apache::thrift::protocol::T_STRING, 28);
+    xfer += oprot->writeBinary(this->key_alias);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.compaction_strategy) {
+    xfer += oprot->writeFieldBegin("compaction_strategy", ::apache::thrift::protocol::T_STRING, 29);
+    xfer += oprot->writeString(this->compaction_strategy);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.compaction_strategy_options) {
+    xfer += oprot->writeFieldBegin("compaction_strategy_options", ::apache::thrift::protocol::T_MAP, 30);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->compaction_strategy_options.size()));
+      std::map<std::string, std::string> ::const_iterator _iter92;
+      for (_iter92 = this->compaction_strategy_options.begin(); _iter92 != this->compaction_strategy_options.end(); ++_iter92)
+      {
+        xfer += oprot->writeString(_iter92->first);
+        xfer += oprot->writeString(_iter92->second);
+      }
+      xfer += oprot->writeMapEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.row_cache_keys_to_save) {
+    xfer += oprot->writeFieldBegin("row_cache_keys_to_save", ::apache::thrift::protocol::T_I32, 31);
+    xfer += op