accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From e..@apache.org
Subject [07/18] accumulo git commit: ACCUMULO-4077 back out a couple of 0.9.1 hacks, run the new compiler
Date Wed, 16 Dec 2015 21:11:12 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3af75fc6/proxy/src/main/cpp/proxy_types.cpp
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/proxy_types.cpp b/proxy/src/main/cpp/proxy_types.cpp
index a055b48..8c443e0 100644
--- a/proxy/src/main/cpp/proxy_types.cpp
+++ b/proxy/src/main/cpp/proxy_types.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 /**
- * Autogenerated by Thrift Compiler (0.9.1)
+ * Autogenerated by Thrift Compiler (0.9.3)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -23,6 +23,9 @@
 #include "proxy_types.h"
 
 #include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
 
 namespace accumulo {
 
@@ -190,11 +193,35 @@ const char* _kTimeTypeNames[] = {
 };
 const std::map<int, const char*> _TimeType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kTimeTypeValues, _kTimeTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
 
-const char* Key::ascii_fingerprint = "91151A432E03F5E8564877B5194B48E2";
-const uint8_t Key::binary_fingerprint[16] = {0x91,0x15,0x1A,0x43,0x2E,0x03,0xF5,0xE8,0x56,0x48,0x77,0xB5,0x19,0x4B,0x48,0xE2};
+
+Key::~Key() throw() {
+}
+
+
+void Key::__set_row(const std::string& val) {
+  this->row = val;
+}
+
+void Key::__set_colFamily(const std::string& val) {
+  this->colFamily = val;
+}
+
+void Key::__set_colQualifier(const std::string& val) {
+  this->colQualifier = val;
+}
+
+void Key::__set_colVisibility(const std::string& val) {
+  this->colVisibility = val;
+}
+
+void Key::__set_timestamp(const int64_t val) {
+  this->timestamp = val;
+__isset.timestamp = true;
+}
 
 uint32_t Key::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -267,6 +294,7 @@ uint32_t Key::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Key::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("Key");
 
   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
@@ -305,11 +333,70 @@ void swap(Key &a, Key &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ColumnUpdate::ascii_fingerprint = "65CC1863F7DDC1DE75B9EAF9E2DC0D1F";
-const uint8_t ColumnUpdate::binary_fingerprint[16] = {0x65,0xCC,0x18,0x63,0xF7,0xDD,0xC1,0xDE,0x75,0xB9,0xEA,0xF9,0xE2,0xDC,0x0D,0x1F};
+Key::Key(const Key& other0) {
+  row = other0.row;
+  colFamily = other0.colFamily;
+  colQualifier = other0.colQualifier;
+  colVisibility = other0.colVisibility;
+  timestamp = other0.timestamp;
+  __isset = other0.__isset;
+}
+Key& Key::operator=(const Key& other1) {
+  row = other1.row;
+  colFamily = other1.colFamily;
+  colQualifier = other1.colQualifier;
+  colVisibility = other1.colVisibility;
+  timestamp = other1.timestamp;
+  __isset = other1.__isset;
+  return *this;
+}
+void Key::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Key(";
+  out << "row=" << to_string(row);
+  out << ", " << "colFamily=" << to_string(colFamily);
+  out << ", " << "colQualifier=" << to_string(colQualifier);
+  out << ", " << "colVisibility=" << to_string(colVisibility);
+  out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>"));
+  out << ")";
+}
+
+
+ColumnUpdate::~ColumnUpdate() throw() {
+}
+
+
+void ColumnUpdate::__set_colFamily(const std::string& val) {
+  this->colFamily = val;
+}
+
+void ColumnUpdate::__set_colQualifier(const std::string& val) {
+  this->colQualifier = val;
+}
+
+void ColumnUpdate::__set_colVisibility(const std::string& val) {
+  this->colVisibility = val;
+__isset.colVisibility = true;
+}
+
+void ColumnUpdate::__set_timestamp(const int64_t val) {
+  this->timestamp = val;
+__isset.timestamp = true;
+}
+
+void ColumnUpdate::__set_value(const std::string& val) {
+  this->value = val;
+__isset.value = true;
+}
+
+void ColumnUpdate::__set_deleteCell(const bool val) {
+  this->deleteCell = val;
+__isset.deleteCell = true;
+}
 
 uint32_t ColumnUpdate::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -390,6 +477,7 @@ uint32_t ColumnUpdate::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t ColumnUpdate::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ColumnUpdate");
 
   xfer += oprot->writeFieldBegin("colFamily", ::apache::thrift::protocol::T_STRING, 1);
@@ -436,11 +524,53 @@ void swap(ColumnUpdate &a, ColumnUpdate &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* DiskUsage::ascii_fingerprint = "D26F4F5E2867D41CF7E0391263932D6B";
-const uint8_t DiskUsage::binary_fingerprint[16] = {0xD2,0x6F,0x4F,0x5E,0x28,0x67,0xD4,0x1C,0xF7,0xE0,0x39,0x12,0x63,0x93,0x2D,0x6B};
+ColumnUpdate::ColumnUpdate(const ColumnUpdate& other2) {
+  colFamily = other2.colFamily;
+  colQualifier = other2.colQualifier;
+  colVisibility = other2.colVisibility;
+  timestamp = other2.timestamp;
+  value = other2.value;
+  deleteCell = other2.deleteCell;
+  __isset = other2.__isset;
+}
+ColumnUpdate& ColumnUpdate::operator=(const ColumnUpdate& other3) {
+  colFamily = other3.colFamily;
+  colQualifier = other3.colQualifier;
+  colVisibility = other3.colVisibility;
+  timestamp = other3.timestamp;
+  value = other3.value;
+  deleteCell = other3.deleteCell;
+  __isset = other3.__isset;
+  return *this;
+}
+void ColumnUpdate::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ColumnUpdate(";
+  out << "colFamily=" << to_string(colFamily);
+  out << ", " << "colQualifier=" << to_string(colQualifier);
+  out << ", " << "colVisibility="; (__isset.colVisibility ? (out << to_string(colVisibility)) : (out << "<null>"));
+  out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>"));
+  out << ", " << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ", " << "deleteCell="; (__isset.deleteCell ? (out << to_string(deleteCell)) : (out << "<null>"));
+  out << ")";
+}
+
+
+DiskUsage::~DiskUsage() throw() {
+}
+
+
+void DiskUsage::__set_tables(const std::vector<std::string> & val) {
+  this->tables = val;
+}
+
+void DiskUsage::__set_usage(const int64_t val) {
+  this->usage = val;
+}
 
 uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -463,14 +593,14 @@ uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->tables.clear();
-            uint32_t _size0;
-            ::apache::thrift::protocol::TType _etype3;
-            xfer += iprot->readListBegin(_etype3, _size0);
-            this->tables.resize(_size0);
-            uint32_t _i4;
-            for (_i4 = 0; _i4 < _size0; ++_i4)
+            uint32_t _size4;
+            ::apache::thrift::protocol::TType _etype7;
+            xfer += iprot->readListBegin(_etype7, _size4);
+            this->tables.resize(_size4);
+            uint32_t _i8;
+            for (_i8 = 0; _i8 < _size4; ++_i8)
             {
-              xfer += iprot->readString(this->tables[_i4]);
+              xfer += iprot->readString(this->tables[_i8]);
             }
             xfer += iprot->readListEnd();
           }
@@ -501,15 +631,16 @@ uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t DiskUsage::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("DiskUsage");
 
   xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tables.size()));
-    std::vector<std::string> ::const_iterator _iter5;
-    for (_iter5 = this->tables.begin(); _iter5 != this->tables.end(); ++_iter5)
+    std::vector<std::string> ::const_iterator _iter9;
+    for (_iter9 = this->tables.begin(); _iter9 != this->tables.end(); ++_iter9)
     {
-      xfer += oprot->writeString((*_iter5));
+      xfer += oprot->writeString((*_iter9));
     }
     xfer += oprot->writeListEnd();
   }
@@ -531,11 +662,41 @@ void swap(DiskUsage &a, DiskUsage &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* KeyValue::ascii_fingerprint = "0D0CA44F233F983E00E94228C31ABBD4";
-const uint8_t KeyValue::binary_fingerprint[16] = {0x0D,0x0C,0xA4,0x4F,0x23,0x3F,0x98,0x3E,0x00,0xE9,0x42,0x28,0xC3,0x1A,0xBB,0xD4};
+DiskUsage::DiskUsage(const DiskUsage& other10) {
+  tables = other10.tables;
+  usage = other10.usage;
+  __isset = other10.__isset;
+}
+DiskUsage& DiskUsage::operator=(const DiskUsage& other11) {
+  tables = other11.tables;
+  usage = other11.usage;
+  __isset = other11.__isset;
+  return *this;
+}
+void DiskUsage::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "DiskUsage(";
+  out << "tables=" << to_string(tables);
+  out << ", " << "usage=" << to_string(usage);
+  out << ")";
+}
+
+
+KeyValue::~KeyValue() throw() {
+}
+
+
+void KeyValue::__set_key(const Key& val) {
+  this->key = val;
+}
+
+void KeyValue::__set_value(const std::string& val) {
+  this->value = val;
+}
 
 uint32_t KeyValue::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -584,6 +745,7 @@ uint32_t KeyValue::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t KeyValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("KeyValue");
 
   xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -606,11 +768,41 @@ void swap(KeyValue &a, KeyValue &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ScanResult::ascii_fingerprint = "684A3FCA76EA202FE071A17F8B510E7A";
-const uint8_t ScanResult::binary_fingerprint[16] = {0x68,0x4A,0x3F,0xCA,0x76,0xEA,0x20,0x2F,0xE0,0x71,0xA1,0x7F,0x8B,0x51,0x0E,0x7A};
+KeyValue::KeyValue(const KeyValue& other12) {
+  key = other12.key;
+  value = other12.value;
+  __isset = other12.__isset;
+}
+KeyValue& KeyValue::operator=(const KeyValue& other13) {
+  key = other13.key;
+  value = other13.value;
+  __isset = other13.__isset;
+  return *this;
+}
+void KeyValue::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "KeyValue(";
+  out << "key=" << to_string(key);
+  out << ", " << "value=" << to_string(value);
+  out << ")";
+}
+
+
+ScanResult::~ScanResult() throw() {
+}
+
+
+void ScanResult::__set_results(const std::vector<KeyValue> & val) {
+  this->results = val;
+}
+
+void ScanResult::__set_more(const bool val) {
+  this->more = val;
+}
 
 uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -633,14 +825,14 @@ uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->results.clear();
-            uint32_t _size6;
-            ::apache::thrift::protocol::TType _etype9;
-            xfer += iprot->readListBegin(_etype9, _size6);
-            this->results.resize(_size6);
-            uint32_t _i10;
-            for (_i10 = 0; _i10 < _size6; ++_i10)
+            uint32_t _size14;
+            ::apache::thrift::protocol::TType _etype17;
+            xfer += iprot->readListBegin(_etype17, _size14);
+            this->results.resize(_size14);
+            uint32_t _i18;
+            for (_i18 = 0; _i18 < _size14; ++_i18)
             {
-              xfer += this->results[_i10].read(iprot);
+              xfer += this->results[_i18].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -671,15 +863,16 @@ uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t ScanResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ScanResult");
 
   xfer += oprot->writeFieldBegin("results", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->results.size()));
-    std::vector<KeyValue> ::const_iterator _iter11;
-    for (_iter11 = this->results.begin(); _iter11 != this->results.end(); ++_iter11)
+    std::vector<KeyValue> ::const_iterator _iter19;
+    for (_iter19 = this->results.begin(); _iter19 != this->results.end(); ++_iter19)
     {
-      xfer += (*_iter11).write(oprot);
+      xfer += (*_iter19).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -701,11 +894,49 @@ void swap(ScanResult &a, ScanResult &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* Range::ascii_fingerprint = "84C5BA8DB718E60BFBF3F83867647B45";
-const uint8_t Range::binary_fingerprint[16] = {0x84,0xC5,0xBA,0x8D,0xB7,0x18,0xE6,0x0B,0xFB,0xF3,0xF8,0x38,0x67,0x64,0x7B,0x45};
+ScanResult::ScanResult(const ScanResult& other20) {
+  results = other20.results;
+  more = other20.more;
+  __isset = other20.__isset;
+}
+ScanResult& ScanResult::operator=(const ScanResult& other21) {
+  results = other21.results;
+  more = other21.more;
+  __isset = other21.__isset;
+  return *this;
+}
+void ScanResult::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ScanResult(";
+  out << "results=" << to_string(results);
+  out << ", " << "more=" << to_string(more);
+  out << ")";
+}
+
+
+Range::~Range() throw() {
+}
+
+
+void Range::__set_start(const Key& val) {
+  this->start = val;
+}
+
+void Range::__set_startInclusive(const bool val) {
+  this->startInclusive = val;
+}
+
+void Range::__set_stop(const Key& val) {
+  this->stop = val;
+}
+
+void Range::__set_stopInclusive(const bool val) {
+  this->stopInclusive = val;
+}
 
 uint32_t Range::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -770,6 +1001,7 @@ uint32_t Range::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Range::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("Range");
 
   xfer += oprot->writeFieldBegin("start", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -802,11 +1034,48 @@ void swap(Range &a, Range &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ScanColumn::ascii_fingerprint = "5B708A954C550ECA9C1A49D3C5CAFAB9";
-const uint8_t ScanColumn::binary_fingerprint[16] = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
+Range::Range(const Range& other22) {
+  start = other22.start;
+  startInclusive = other22.startInclusive;
+  stop = other22.stop;
+  stopInclusive = other22.stopInclusive;
+  __isset = other22.__isset;
+}
+Range& Range::operator=(const Range& other23) {
+  start = other23.start;
+  startInclusive = other23.startInclusive;
+  stop = other23.stop;
+  stopInclusive = other23.stopInclusive;
+  __isset = other23.__isset;
+  return *this;
+}
+void Range::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Range(";
+  out << "start=" << to_string(start);
+  out << ", " << "startInclusive=" << to_string(startInclusive);
+  out << ", " << "stop=" << to_string(stop);
+  out << ", " << "stopInclusive=" << to_string(stopInclusive);
+  out << ")";
+}
+
+
+ScanColumn::~ScanColumn() throw() {
+}
+
+
+void ScanColumn::__set_colFamily(const std::string& val) {
+  this->colFamily = val;
+}
+
+void ScanColumn::__set_colQualifier(const std::string& val) {
+  this->colQualifier = val;
+__isset.colQualifier = true;
+}
 
 uint32_t ScanColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -855,6 +1124,7 @@ uint32_t ScanColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t ScanColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ScanColumn");
 
   xfer += oprot->writeFieldBegin("colFamily", ::apache::thrift::protocol::T_STRING, 1);
@@ -878,11 +1148,49 @@ void swap(ScanColumn &a, ScanColumn &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* IteratorSetting::ascii_fingerprint = "985C857916964E43205EAC92A157CB4E";
-const uint8_t IteratorSetting::binary_fingerprint[16] = {0x98,0x5C,0x85,0x79,0x16,0x96,0x4E,0x43,0x20,0x5E,0xAC,0x92,0xA1,0x57,0xCB,0x4E};
+ScanColumn::ScanColumn(const ScanColumn& other24) {
+  colFamily = other24.colFamily;
+  colQualifier = other24.colQualifier;
+  __isset = other24.__isset;
+}
+ScanColumn& ScanColumn::operator=(const ScanColumn& other25) {
+  colFamily = other25.colFamily;
+  colQualifier = other25.colQualifier;
+  __isset = other25.__isset;
+  return *this;
+}
+void ScanColumn::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ScanColumn(";
+  out << "colFamily=" << to_string(colFamily);
+  out << ", " << "colQualifier="; (__isset.colQualifier ? (out << to_string(colQualifier)) : (out << "<null>"));
+  out << ")";
+}
+
+
+IteratorSetting::~IteratorSetting() throw() {
+}
+
+
+void IteratorSetting::__set_priority(const int32_t val) {
+  this->priority = val;
+}
+
+void IteratorSetting::__set_name(const std::string& val) {
+  this->name = val;
+}
+
+void IteratorSetting::__set_iteratorClass(const std::string& val) {
+  this->iteratorClass = val;
+}
+
+void IteratorSetting::__set_properties(const std::map<std::string, std::string> & val) {
+  this->properties = val;
+}
 
 uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -929,17 +1237,17 @@ uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->properties.clear();
-            uint32_t _size12;
-            ::apache::thrift::protocol::TType _ktype13;
-            ::apache::thrift::protocol::TType _vtype14;
-            xfer += iprot->readMapBegin(_ktype13, _vtype14, _size12);
-            uint32_t _i16;
-            for (_i16 = 0; _i16 < _size12; ++_i16)
+            uint32_t _size26;
+            ::apache::thrift::protocol::TType _ktype27;
+            ::apache::thrift::protocol::TType _vtype28;
+            xfer += iprot->readMapBegin(_ktype27, _vtype28, _size26);
+            uint32_t _i30;
+            for (_i30 = 0; _i30 < _size26; ++_i30)
             {
-              std::string _key17;
-              xfer += iprot->readString(_key17);
-              std::string& _val18 = this->properties[_key17];
-              xfer += iprot->readString(_val18);
+              std::string _key31;
+              xfer += iprot->readString(_key31);
+              std::string& _val32 = this->properties[_key31];
+              xfer += iprot->readString(_val32);
             }
             xfer += iprot->readMapEnd();
           }
@@ -962,6 +1270,7 @@ uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t IteratorSetting::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("IteratorSetting");
 
   xfer += oprot->writeFieldBegin("priority", ::apache::thrift::protocol::T_I32, 1);
@@ -979,11 +1288,11 @@ uint32_t IteratorSetting::write(::apache::thrift::protocol::TProtocol* oprot) co
   xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 4);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
-    std::map<std::string, std::string> ::const_iterator _iter19;
-    for (_iter19 = this->properties.begin(); _iter19 != this->properties.end(); ++_iter19)
+    std::map<std::string, std::string> ::const_iterator _iter33;
+    for (_iter33 = this->properties.begin(); _iter33 != this->properties.end(); ++_iter33)
     {
-      xfer += oprot->writeString(_iter19->first);
-      xfer += oprot->writeString(_iter19->second);
+      xfer += oprot->writeString(_iter33->first);
+      xfer += oprot->writeString(_iter33->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -1003,11 +1312,64 @@ void swap(IteratorSetting &a, IteratorSetting &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ScanOptions::ascii_fingerprint = "3D87D0CD05FA62E15880C4D2C595907C";
-const uint8_t ScanOptions::binary_fingerprint[16] = {0x3D,0x87,0xD0,0xCD,0x05,0xFA,0x62,0xE1,0x58,0x80,0xC4,0xD2,0xC5,0x95,0x90,0x7C};
+IteratorSetting::IteratorSetting(const IteratorSetting& other34) {
+  priority = other34.priority;
+  name = other34.name;
+  iteratorClass = other34.iteratorClass;
+  properties = other34.properties;
+  __isset = other34.__isset;
+}
+IteratorSetting& IteratorSetting::operator=(const IteratorSetting& other35) {
+  priority = other35.priority;
+  name = other35.name;
+  iteratorClass = other35.iteratorClass;
+  properties = other35.properties;
+  __isset = other35.__isset;
+  return *this;
+}
+void IteratorSetting::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "IteratorSetting(";
+  out << "priority=" << to_string(priority);
+  out << ", " << "name=" << to_string(name);
+  out << ", " << "iteratorClass=" << to_string(iteratorClass);
+  out << ", " << "properties=" << to_string(properties);
+  out << ")";
+}
+
+
+ScanOptions::~ScanOptions() throw() {
+}
+
+
+void ScanOptions::__set_authorizations(const std::set<std::string> & val) {
+  this->authorizations = val;
+__isset.authorizations = true;
+}
+
+void ScanOptions::__set_range(const Range& val) {
+  this->range = val;
+__isset.range = true;
+}
+
+void ScanOptions::__set_columns(const std::vector<ScanColumn> & val) {
+  this->columns = val;
+__isset.columns = true;
+}
+
+void ScanOptions::__set_iterators(const std::vector<IteratorSetting> & val) {
+  this->iterators = val;
+__isset.iterators = true;
+}
+
+void ScanOptions::__set_bufferSize(const int32_t val) {
+  this->bufferSize = val;
+__isset.bufferSize = true;
+}
 
 uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1030,15 +1392,15 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->authorizations.clear();
-            uint32_t _size20;
-            ::apache::thrift::protocol::TType _etype23;
-            xfer += iprot->readSetBegin(_etype23, _size20);
-            uint32_t _i24;
-            for (_i24 = 0; _i24 < _size20; ++_i24)
+            uint32_t _size36;
+            ::apache::thrift::protocol::TType _etype39;
+            xfer += iprot->readSetBegin(_etype39, _size36);
+            uint32_t _i40;
+            for (_i40 = 0; _i40 < _size36; ++_i40)
             {
-              std::string _elem25;
-              xfer += iprot->readBinary(_elem25);
-              this->authorizations.insert(_elem25);
+              std::string _elem41;
+              xfer += iprot->readBinary(_elem41);
+              this->authorizations.insert(_elem41);
             }
             xfer += iprot->readSetEnd();
           }
@@ -1059,14 +1421,14 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->columns.clear();
-            uint32_t _size26;
-            ::apache::thrift::protocol::TType _etype29;
-            xfer += iprot->readListBegin(_etype29, _size26);
-            this->columns.resize(_size26);
-            uint32_t _i30;
-            for (_i30 = 0; _i30 < _size26; ++_i30)
+            uint32_t _size42;
+            ::apache::thrift::protocol::TType _etype45;
+            xfer += iprot->readListBegin(_etype45, _size42);
+            this->columns.resize(_size42);
+            uint32_t _i46;
+            for (_i46 = 0; _i46 < _size42; ++_i46)
             {
-              xfer += this->columns[_i30].read(iprot);
+              xfer += this->columns[_i46].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1079,14 +1441,14 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size31;
-            ::apache::thrift::protocol::TType _etype34;
-            xfer += iprot->readListBegin(_etype34, _size31);
-            this->iterators.resize(_size31);
-            uint32_t _i35;
-            for (_i35 = 0; _i35 < _size31; ++_i35)
+            uint32_t _size47;
+            ::apache::thrift::protocol::TType _etype50;
+            xfer += iprot->readListBegin(_etype50, _size47);
+            this->iterators.resize(_size47);
+            uint32_t _i51;
+            for (_i51 = 0; _i51 < _size47; ++_i51)
             {
-              xfer += this->iterators[_i35].read(iprot);
+              xfer += this->iterators[_i51].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1117,16 +1479,17 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ScanOptions");
 
   if (this->__isset.authorizations) {
     xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size()));
-      std::set<std::string> ::const_iterator _iter36;
-      for (_iter36 = this->authorizations.begin(); _iter36 != this->authorizations.end(); ++_iter36)
+      std::set<std::string> ::const_iterator _iter52;
+      for (_iter52 = this->authorizations.begin(); _iter52 != this->authorizations.end(); ++_iter52)
       {
-        xfer += oprot->writeBinary((*_iter36));
+        xfer += oprot->writeBinary((*_iter52));
       }
       xfer += oprot->writeSetEnd();
     }
@@ -1141,10 +1504,10 @@ uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-      std::vector<ScanColumn> ::const_iterator _iter37;
-      for (_iter37 = this->columns.begin(); _iter37 != this->columns.end(); ++_iter37)
+      std::vector<ScanColumn> ::const_iterator _iter53;
+      for (_iter53 = this->columns.begin(); _iter53 != this->columns.end(); ++_iter53)
       {
-        xfer += (*_iter37).write(oprot);
+        xfer += (*_iter53).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -1154,10 +1517,10 @@ uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-      std::vector<IteratorSetting> ::const_iterator _iter38;
-      for (_iter38 = this->iterators.begin(); _iter38 != this->iterators.end(); ++_iter38)
+      std::vector<IteratorSetting> ::const_iterator _iter54;
+      for (_iter54 = this->iterators.begin(); _iter54 != this->iterators.end(); ++_iter54)
       {
-        xfer += (*_iter38).write(oprot);
+        xfer += (*_iter54).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -1183,11 +1546,67 @@ void swap(ScanOptions &a, ScanOptions &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* BatchScanOptions::ascii_fingerprint = "6ADFA1FBE31B1220D2C103284E002308";
-const uint8_t BatchScanOptions::binary_fingerprint[16] = {0x6A,0xDF,0xA1,0xFB,0xE3,0x1B,0x12,0x20,0xD2,0xC1,0x03,0x28,0x4E,0x00,0x23,0x08};
+ScanOptions::ScanOptions(const ScanOptions& other55) {
+  authorizations = other55.authorizations;
+  range = other55.range;
+  columns = other55.columns;
+  iterators = other55.iterators;
+  bufferSize = other55.bufferSize;
+  __isset = other55.__isset;
+}
+ScanOptions& ScanOptions::operator=(const ScanOptions& other56) {
+  authorizations = other56.authorizations;
+  range = other56.range;
+  columns = other56.columns;
+  iterators = other56.iterators;
+  bufferSize = other56.bufferSize;
+  __isset = other56.__isset;
+  return *this;
+}
+void ScanOptions::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ScanOptions(";
+  out << "authorizations="; (__isset.authorizations ? (out << to_string(authorizations)) : (out << "<null>"));
+  out << ", " << "range="; (__isset.range ? (out << to_string(range)) : (out << "<null>"));
+  out << ", " << "columns="; (__isset.columns ? (out << to_string(columns)) : (out << "<null>"));
+  out << ", " << "iterators="; (__isset.iterators ? (out << to_string(iterators)) : (out << "<null>"));
+  out << ", " << "bufferSize="; (__isset.bufferSize ? (out << to_string(bufferSize)) : (out << "<null>"));
+  out << ")";
+}
+
+
+BatchScanOptions::~BatchScanOptions() throw() {
+}
+
+
+void BatchScanOptions::__set_authorizations(const std::set<std::string> & val) {
+  this->authorizations = val;
+__isset.authorizations = true;
+}
+
+void BatchScanOptions::__set_ranges(const std::vector<Range> & val) {
+  this->ranges = val;
+__isset.ranges = true;
+}
+
+void BatchScanOptions::__set_columns(const std::vector<ScanColumn> & val) {
+  this->columns = val;
+__isset.columns = true;
+}
+
+void BatchScanOptions::__set_iterators(const std::vector<IteratorSetting> & val) {
+  this->iterators = val;
+__isset.iterators = true;
+}
+
+void BatchScanOptions::__set_threads(const int32_t val) {
+  this->threads = val;
+__isset.threads = true;
+}
 
 uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1210,15 +1629,15 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->authorizations.clear();
-            uint32_t _size39;
-            ::apache::thrift::protocol::TType _etype42;
-            xfer += iprot->readSetBegin(_etype42, _size39);
-            uint32_t _i43;
-            for (_i43 = 0; _i43 < _size39; ++_i43)
+            uint32_t _size57;
+            ::apache::thrift::protocol::TType _etype60;
+            xfer += iprot->readSetBegin(_etype60, _size57);
+            uint32_t _i61;
+            for (_i61 = 0; _i61 < _size57; ++_i61)
             {
-              std::string _elem44;
-              xfer += iprot->readBinary(_elem44);
-              this->authorizations.insert(_elem44);
+              std::string _elem62;
+              xfer += iprot->readBinary(_elem62);
+              this->authorizations.insert(_elem62);
             }
             xfer += iprot->readSetEnd();
           }
@@ -1231,14 +1650,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->ranges.clear();
-            uint32_t _size45;
-            ::apache::thrift::protocol::TType _etype48;
-            xfer += iprot->readListBegin(_etype48, _size45);
-            this->ranges.resize(_size45);
-            uint32_t _i49;
-            for (_i49 = 0; _i49 < _size45; ++_i49)
+            uint32_t _size63;
+            ::apache::thrift::protocol::TType _etype66;
+            xfer += iprot->readListBegin(_etype66, _size63);
+            this->ranges.resize(_size63);
+            uint32_t _i67;
+            for (_i67 = 0; _i67 < _size63; ++_i67)
             {
-              xfer += this->ranges[_i49].read(iprot);
+              xfer += this->ranges[_i67].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1251,14 +1670,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->columns.clear();
-            uint32_t _size50;
-            ::apache::thrift::protocol::TType _etype53;
-            xfer += iprot->readListBegin(_etype53, _size50);
-            this->columns.resize(_size50);
-            uint32_t _i54;
-            for (_i54 = 0; _i54 < _size50; ++_i54)
+            uint32_t _size68;
+            ::apache::thrift::protocol::TType _etype71;
+            xfer += iprot->readListBegin(_etype71, _size68);
+            this->columns.resize(_size68);
+            uint32_t _i72;
+            for (_i72 = 0; _i72 < _size68; ++_i72)
             {
-              xfer += this->columns[_i54].read(iprot);
+              xfer += this->columns[_i72].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1271,14 +1690,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size55;
-            ::apache::thrift::protocol::TType _etype58;
-            xfer += iprot->readListBegin(_etype58, _size55);
-            this->iterators.resize(_size55);
-            uint32_t _i59;
-            for (_i59 = 0; _i59 < _size55; ++_i59)
+            uint32_t _size73;
+            ::apache::thrift::protocol::TType _etype76;
+            xfer += iprot->readListBegin(_etype76, _size73);
+            this->iterators.resize(_size73);
+            uint32_t _i77;
+            for (_i77 = 0; _i77 < _size73; ++_i77)
             {
-              xfer += this->iterators[_i59].read(iprot);
+              xfer += this->iterators[_i77].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1309,16 +1728,17 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("BatchScanOptions");
 
   if (this->__isset.authorizations) {
     xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size()));
-      std::set<std::string> ::const_iterator _iter60;
-      for (_iter60 = this->authorizations.begin(); _iter60 != this->authorizations.end(); ++_iter60)
+      std::set<std::string> ::const_iterator _iter78;
+      for (_iter78 = this->authorizations.begin(); _iter78 != this->authorizations.end(); ++_iter78)
       {
-        xfer += oprot->writeBinary((*_iter60));
+        xfer += oprot->writeBinary((*_iter78));
       }
       xfer += oprot->writeSetEnd();
     }
@@ -1328,10 +1748,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c
     xfer += oprot->writeFieldBegin("ranges", ::apache::thrift::protocol::T_LIST, 2);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->ranges.size()));
-      std::vector<Range> ::const_iterator _iter61;
-      for (_iter61 = this->ranges.begin(); _iter61 != this->ranges.end(); ++_iter61)
+      std::vector<Range> ::const_iterator _iter79;
+      for (_iter79 = this->ranges.begin(); _iter79 != this->ranges.end(); ++_iter79)
       {
-        xfer += (*_iter61).write(oprot);
+        xfer += (*_iter79).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -1341,10 +1761,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c
     xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-      std::vector<ScanColumn> ::const_iterator _iter62;
-      for (_iter62 = this->columns.begin(); _iter62 != this->columns.end(); ++_iter62)
+      std::vector<ScanColumn> ::const_iterator _iter80;
+      for (_iter80 = this->columns.begin(); _iter80 != this->columns.end(); ++_iter80)
       {
-        xfer += (*_iter62).write(oprot);
+        xfer += (*_iter80).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -1354,10 +1774,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c
     xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-      std::vector<IteratorSetting> ::const_iterator _iter63;
-      for (_iter63 = this->iterators.begin(); _iter63 != this->iterators.end(); ++_iter63)
+      std::vector<IteratorSetting> ::const_iterator _iter81;
+      for (_iter81 = this->iterators.begin(); _iter81 != this->iterators.end(); ++_iter81)
       {
-        xfer += (*_iter63).write(oprot);
+        xfer += (*_iter81).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -1383,11 +1803,50 @@ void swap(BatchScanOptions &a, BatchScanOptions &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* KeyValueAndPeek::ascii_fingerprint = "CBBC6AB9C7EA5E5E748C13F970862FAB";
-const uint8_t KeyValueAndPeek::binary_fingerprint[16] = {0xCB,0xBC,0x6A,0xB9,0xC7,0xEA,0x5E,0x5E,0x74,0x8C,0x13,0xF9,0x70,0x86,0x2F,0xAB};
+BatchScanOptions::BatchScanOptions(const BatchScanOptions& other82) {
+  authorizations = other82.authorizations;
+  ranges = other82.ranges;
+  columns = other82.columns;
+  iterators = other82.iterators;
+  threads = other82.threads;
+  __isset = other82.__isset;
+}
+BatchScanOptions& BatchScanOptions::operator=(const BatchScanOptions& other83) {
+  authorizations = other83.authorizations;
+  ranges = other83.ranges;
+  columns = other83.columns;
+  iterators = other83.iterators;
+  threads = other83.threads;
+  __isset = other83.__isset;
+  return *this;
+}
+void BatchScanOptions::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "BatchScanOptions(";
+  out << "authorizations="; (__isset.authorizations ? (out << to_string(authorizations)) : (out << "<null>"));
+  out << ", " << "ranges="; (__isset.ranges ? (out << to_string(ranges)) : (out << "<null>"));
+  out << ", " << "columns="; (__isset.columns ? (out << to_string(columns)) : (out << "<null>"));
+  out << ", " << "iterators="; (__isset.iterators ? (out << to_string(iterators)) : (out << "<null>"));
+  out << ", " << "threads="; (__isset.threads ? (out << to_string(threads)) : (out << "<null>"));
+  out << ")";
+}
+
+
+KeyValueAndPeek::~KeyValueAndPeek() throw() {
+}
+
+
+void KeyValueAndPeek::__set_keyValue(const KeyValue& val) {
+  this->keyValue = val;
+}
+
+void KeyValueAndPeek::__set_hasNext(const bool val) {
+  this->hasNext = val;
+}
 
 uint32_t KeyValueAndPeek::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1436,6 +1895,7 @@ uint32_t KeyValueAndPeek::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t KeyValueAndPeek::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("KeyValueAndPeek");
 
   xfer += oprot->writeFieldBegin("keyValue", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -1458,11 +1918,45 @@ void swap(KeyValueAndPeek &a, KeyValueAndPeek &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* KeyExtent::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
-const uint8_t KeyExtent::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+KeyValueAndPeek::KeyValueAndPeek(const KeyValueAndPeek& other84) {
+  keyValue = other84.keyValue;
+  hasNext = other84.hasNext;
+  __isset = other84.__isset;
+}
+KeyValueAndPeek& KeyValueAndPeek::operator=(const KeyValueAndPeek& other85) {
+  keyValue = other85.keyValue;
+  hasNext = other85.hasNext;
+  __isset = other85.__isset;
+  return *this;
+}
+void KeyValueAndPeek::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "KeyValueAndPeek(";
+  out << "keyValue=" << to_string(keyValue);
+  out << ", " << "hasNext=" << to_string(hasNext);
+  out << ")";
+}
+
+
+KeyExtent::~KeyExtent() throw() {
+}
+
+
+void KeyExtent::__set_tableId(const std::string& val) {
+  this->tableId = val;
+}
+
+void KeyExtent::__set_endRow(const std::string& val) {
+  this->endRow = val;
+}
+
+void KeyExtent::__set_prevEndRow(const std::string& val) {
+  this->prevEndRow = val;
+}
 
 uint32_t KeyExtent::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1519,6 +2013,7 @@ uint32_t KeyExtent::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t KeyExtent::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("KeyExtent");
 
   xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_STRING, 1);
@@ -1546,11 +2041,48 @@ void swap(KeyExtent &a, KeyExtent &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* Column::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
-const uint8_t Column::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+KeyExtent::KeyExtent(const KeyExtent& other86) {
+  tableId = other86.tableId;
+  endRow = other86.endRow;
+  prevEndRow = other86.prevEndRow;
+  __isset = other86.__isset;
+}
+KeyExtent& KeyExtent::operator=(const KeyExtent& other87) {
+  tableId = other87.tableId;
+  endRow = other87.endRow;
+  prevEndRow = other87.prevEndRow;
+  __isset = other87.__isset;
+  return *this;
+}
+void KeyExtent::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "KeyExtent(";
+  out << "tableId=" << to_string(tableId);
+  out << ", " << "endRow=" << to_string(endRow);
+  out << ", " << "prevEndRow=" << to_string(prevEndRow);
+  out << ")";
+}
+
+
+Column::~Column() throw() {
+}
+
+
+void Column::__set_colFamily(const std::string& val) {
+  this->colFamily = val;
+}
+
+void Column::__set_colQualifier(const std::string& val) {
+  this->colQualifier = val;
+}
+
+void Column::__set_colVisibility(const std::string& val) {
+  this->colVisibility = val;
+}
 
 uint32_t Column::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1607,6 +2139,7 @@ uint32_t Column::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("Column");
 
   xfer += oprot->writeFieldBegin("colFamily", ::apache::thrift::protocol::T_STRING, 1);
@@ -1634,11 +2167,55 @@ void swap(Column &a, Column &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* Condition::ascii_fingerprint = "C4022914C22D89E33B1A46A7D511C58F";
-const uint8_t Condition::binary_fingerprint[16] = {0xC4,0x02,0x29,0x14,0xC2,0x2D,0x89,0xE3,0x3B,0x1A,0x46,0xA7,0xD5,0x11,0xC5,0x8F};
+Column::Column(const Column& other88) {
+  colFamily = other88.colFamily;
+  colQualifier = other88.colQualifier;
+  colVisibility = other88.colVisibility;
+  __isset = other88.__isset;
+}
+Column& Column::operator=(const Column& other89) {
+  colFamily = other89.colFamily;
+  colQualifier = other89.colQualifier;
+  colVisibility = other89.colVisibility;
+  __isset = other89.__isset;
+  return *this;
+}
+void Column::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Column(";
+  out << "colFamily=" << to_string(colFamily);
+  out << ", " << "colQualifier=" << to_string(colQualifier);
+  out << ", " << "colVisibility=" << to_string(colVisibility);
+  out << ")";
+}
+
+
+Condition::~Condition() throw() {
+}
+
+
+void Condition::__set_column(const Column& val) {
+  this->column = val;
+}
+
+void Condition::__set_timestamp(const int64_t val) {
+  this->timestamp = val;
+__isset.timestamp = true;
+}
+
+void Condition::__set_value(const std::string& val) {
+  this->value = val;
+__isset.value = true;
+}
+
+void Condition::__set_iterators(const std::vector<IteratorSetting> & val) {
+  this->iterators = val;
+__isset.iterators = true;
+}
 
 uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1685,14 +2262,14 @@ uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size64;
-            ::apache::thrift::protocol::TType _etype67;
-            xfer += iprot->readListBegin(_etype67, _size64);
-            this->iterators.resize(_size64);
-            uint32_t _i68;
-            for (_i68 = 0; _i68 < _size64; ++_i68)
+            uint32_t _size90;
+            ::apache::thrift::protocol::TType _etype93;
+            xfer += iprot->readListBegin(_etype93, _size90);
+            this->iterators.resize(_size90);
+            uint32_t _i94;
+            for (_i94 = 0; _i94 < _size90; ++_i94)
             {
-              xfer += this->iterators[_i68].read(iprot);
+              xfer += this->iterators[_i94].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1715,6 +2292,7 @@ uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Condition::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("Condition");
 
   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -1735,10 +2313,10 @@ uint32_t Condition::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-      std::vector<IteratorSetting> ::const_iterator _iter69;
-      for (_iter69 = this->iterators.begin(); _iter69 != this->iterators.end(); ++_iter69)
+      std::vector<IteratorSetting> ::const_iterator _iter95;
+      for (_iter95 = this->iterators.begin(); _iter95 != this->iterators.end(); ++_iter95)
       {
-        xfer += (*_iter69).write(oprot);
+        xfer += (*_iter95).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -1758,11 +2336,47 @@ void swap(Condition &a, Condition &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ConditionalUpdates::ascii_fingerprint = "1C1808872D1A8E04F114974ADD77F356";
-const uint8_t ConditionalUpdates::binary_fingerprint[16] = {0x1C,0x18,0x08,0x87,0x2D,0x1A,0x8E,0x04,0xF1,0x14,0x97,0x4A,0xDD,0x77,0xF3,0x56};
+Condition::Condition(const Condition& other96) {
+  column = other96.column;
+  timestamp = other96.timestamp;
+  value = other96.value;
+  iterators = other96.iterators;
+  __isset = other96.__isset;
+}
+Condition& Condition::operator=(const Condition& other97) {
+  column = other97.column;
+  timestamp = other97.timestamp;
+  value = other97.value;
+  iterators = other97.iterators;
+  __isset = other97.__isset;
+  return *this;
+}
+void Condition::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Condition(";
+  out << "column=" << to_string(column);
+  out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>"));
+  out << ", " << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+  out << ", " << "iterators="; (__isset.iterators ? (out << to_string(iterators)) : (out << "<null>"));
+  out << ")";
+}
+
+
+ConditionalUpdates::~ConditionalUpdates() throw() {
+}
+
+
+void ConditionalUpdates::__set_conditions(const std::vector<Condition> & val) {
+  this->conditions = val;
+}
+
+void ConditionalUpdates::__set_updates(const std::vector<ColumnUpdate> & val) {
+  this->updates = val;
+}
 
 uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1785,14 +2399,14 @@ uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot)
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->conditions.clear();
-            uint32_t _size70;
-            ::apache::thrift::protocol::TType _etype73;
-            xfer += iprot->readListBegin(_etype73, _size70);
-            this->conditions.resize(_size70);
-            uint32_t _i74;
-            for (_i74 = 0; _i74 < _size70; ++_i74)
+            uint32_t _size98;
+            ::apache::thrift::protocol::TType _etype101;
+            xfer += iprot->readListBegin(_etype101, _size98);
+            this->conditions.resize(_size98);
+            uint32_t _i102;
+            for (_i102 = 0; _i102 < _size98; ++_i102)
             {
-              xfer += this->conditions[_i74].read(iprot);
+              xfer += this->conditions[_i102].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1805,14 +2419,14 @@ uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot)
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->updates.clear();
-            uint32_t _size75;
-            ::apache::thrift::protocol::TType _etype78;
-            xfer += iprot->readListBegin(_etype78, _size75);
-            this->updates.resize(_size75);
-            uint32_t _i79;
-            for (_i79 = 0; _i79 < _size75; ++_i79)
+            uint32_t _size103;
+            ::apache::thrift::protocol::TType _etype106;
+            xfer += iprot->readListBegin(_etype106, _size103);
+            this->updates.resize(_size103);
+            uint32_t _i107;
+            for (_i107 = 0; _i107 < _size103; ++_i107)
             {
-              xfer += this->updates[_i79].read(iprot);
+              xfer += this->updates[_i107].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1835,15 +2449,16 @@ uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot)
 
 uint32_t ConditionalUpdates::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ConditionalUpdates");
 
   xfer += oprot->writeFieldBegin("conditions", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->conditions.size()));
-    std::vector<Condition> ::const_iterator _iter80;
-    for (_iter80 = this->conditions.begin(); _iter80 != this->conditions.end(); ++_iter80)
+    std::vector<Condition> ::const_iterator _iter108;
+    for (_iter108 = this->conditions.begin(); _iter108 != this->conditions.end(); ++_iter108)
     {
-      xfer += (*_iter80).write(oprot);
+      xfer += (*_iter108).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -1852,10 +2467,10 @@ uint32_t ConditionalUpdates::write(::apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("updates", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->updates.size()));
-    std::vector<ColumnUpdate> ::const_iterator _iter81;
-    for (_iter81 = this->updates.begin(); _iter81 != this->updates.end(); ++_iter81)
+    std::vector<ColumnUpdate> ::const_iterator _iter109;
+    for (_iter109 = this->updates.begin(); _iter109 != this->updates.end(); ++_iter109)
     {
-      xfer += (*_iter81).write(oprot);
+      xfer += (*_iter109).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -1873,11 +2488,58 @@ void swap(ConditionalUpdates &a, ConditionalUpdates &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ConditionalWriterOptions::ascii_fingerprint = "C345C04E84A351638B6EACB741BD600E";
-const uint8_t ConditionalWriterOptions::binary_fingerprint[16] = {0xC3,0x45,0xC0,0x4E,0x84,0xA3,0x51,0x63,0x8B,0x6E,0xAC,0xB7,0x41,0xBD,0x60,0x0E};
+ConditionalUpdates::ConditionalUpdates(const ConditionalUpdates& other110) {
+  conditions = other110.conditions;
+  updates = other110.updates;
+  __isset = other110.__isset;
+}
+ConditionalUpdates& ConditionalUpdates::operator=(const ConditionalUpdates& other111) {
+  conditions = other111.conditions;
+  updates = other111.updates;
+  __isset = other111.__isset;
+  return *this;
+}
+void ConditionalUpdates::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ConditionalUpdates(";
+  out << "conditions=" << to_string(conditions);
+  out << ", " << "updates=" << to_string(updates);
+  out << ")";
+}
+
+
+ConditionalWriterOptions::~ConditionalWriterOptions() throw() {
+}
+
+
+void ConditionalWriterOptions::__set_maxMemory(const int64_t val) {
+  this->maxMemory = val;
+__isset.maxMemory = true;
+}
+
+void ConditionalWriterOptions::__set_timeoutMs(const int64_t val) {
+  this->timeoutMs = val;
+__isset.timeoutMs = true;
+}
+
+void ConditionalWriterOptions::__set_threads(const int32_t val) {
+  this->threads = val;
+__isset.threads = true;
+}
+
+void ConditionalWriterOptions::__set_authorizations(const std::set<std::string> & val) {
+  this->authorizations = val;
+__isset.authorizations = true;
+}
+
+void ConditionalWriterOptions::__set_durability(const Durability::type val) {
+  this->durability = val;
+__isset.durability = true;
+}
 
 uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1924,15 +2586,15 @@ uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* i
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->authorizations.clear();
-            uint32_t _size82;
-            ::apache::thrift::protocol::TType _etype85;
-            xfer += iprot->readSetBegin(_etype85, _size82);
-            uint32_t _i86;
-            for (_i86 = 0; _i86 < _size82; ++_i86)
+            uint32_t _size112;
+            ::apache::thrift::protocol::TType _etype115;
+            xfer += iprot->readSetBegin(_etype115, _size112);
+            uint32_t _i116;
+            for (_i116 = 0; _i116 < _size112; ++_i116)
             {
-              std::string _elem87;
-              xfer += iprot->readBinary(_elem87);
-              this->authorizations.insert(_elem87);
+              std::string _elem117;
+              xfer += iprot->readBinary(_elem117);
+              this->authorizations.insert(_elem117);
             }
             xfer += iprot->readSetEnd();
           }
@@ -1943,9 +2605,9 @@ uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* i
         break;
       case 5:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast88;
-          xfer += iprot->readI32(ecast88);
-          this->durability = (Durability::type)ecast88;
+          int32_t ecast118;
+          xfer += iprot->readI32(ecast118);
+          this->durability = (Durability::type)ecast118;
           this->__isset.durability = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1965,6 +2627,7 @@ uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* i
 
 uint32_t ConditionalWriterOptions::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ConditionalWriterOptions");
 
   if (this->__isset.maxMemory) {
@@ -1986,10 +2649,10 @@ uint32_t ConditionalWriterOptions::write(::apache::thrift::protocol::TProtocol*
     xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 4);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size()));
-      std::set<std::string> ::const_iterator _iter89;
-      for (_iter89 = this->authorizations.begin(); _iter89 != this->authorizations.end(); ++_iter89)
+      std::set<std::string> ::const_iterator _iter119;
+      for (_iter119 = this->authorizations.begin(); _iter119 != this->authorizations.end(); ++_iter119)
       {
-        xfer += oprot->writeBinary((*_iter89));
+        xfer += oprot->writeBinary((*_iter119));
       }
       xfer += oprot->writeSetEnd();
     }
@@ -2015,11 +2678,86 @@ void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ActiveScan::ascii_fingerprint = "1B97541CB4E900A054266BBBEE61D004";
-const uint8_t ActiveScan::binary_fingerprint[16] = {0x1B,0x97,0x54,0x1C,0xB4,0xE9,0x00,0xA0,0x54,0x26,0x6B,0xBB,0xEE,0x61,0xD0,0x04};
+ConditionalWriterOptions::ConditionalWriterOptions(const ConditionalWriterOptions& other120) {
+  maxMemory = other120.maxMemory;
+  timeoutMs = other120.timeoutMs;
+  threads = other120.threads;
+  authorizations = other120.authorizations;
+  durability = other120.durability;
+  __isset = other120.__isset;
+}
+ConditionalWriterOptions& ConditionalWriterOptions::operator=(const ConditionalWriterOptions& other121) {
+  maxMemory = other121.maxMemory;
+  timeoutMs = other121.timeoutMs;
+  threads = other121.threads;
+  authorizations = other121.authorizations;
+  durability = other121.durability;
+  __isset = other121.__isset;
+  return *this;
+}
+void ConditionalWriterOptions::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ConditionalWriterOptions(";
+  out << "maxMemory="; (__isset.maxMemory ? (out << to_string(maxMemory)) : (out << "<null>"));
+  out << ", " << "timeoutMs="; (__isset.timeoutMs ? (out << to_string(timeoutMs)) : (out << "<null>"));
+  out << ", " << "threads="; (__isset.threads ? (out << to_string(threads)) : (out << "<null>"));
+  out << ", " << "authorizations="; (__isset.authorizations ? (out << to_string(authorizations)) : (out << "<null>"));
+  out << ", " << "durability="; (__isset.durability ? (out << to_string(durability)) : (out << "<null>"));
+  out << ")";
+}
+
+
+ActiveScan::~ActiveScan() throw() {
+}
+
+
+void ActiveScan::__set_client(const std::string& val) {
+  this->client = val;
+}
+
+void ActiveScan::__set_user(const std::string& val) {
+  this->user = val;
+}
+
+void ActiveScan::__set_table(const std::string& val) {
+  this->table = val;
+}
+
+void ActiveScan::__set_age(const int64_t val) {
+  this->age = val;
+}
+
+void ActiveScan::__set_idleTime(const int64_t val) {
+  this->idleTime = val;
+}
+
+void ActiveScan::__set_type(const ScanType::type val) {
+  this->type = val;
+}
+
+void ActiveScan::__set_state(const ScanState::type val) {
+  this->state = val;
+}
+
+void ActiveScan::__set_extent(const KeyExtent& val) {
+  this->extent = val;
+}
+
+void ActiveScan::__set_columns(const std::vector<Column> & val) {
+  this->columns = val;
+}
+
+void ActiveScan::__set_iterators(const std::vector<IteratorSetting> & val) {
+  this->iterators = val;
+}
+
+void ActiveScan::__set_authorizations(const std::vector<std::string> & val) {
+  this->authorizations = val;
+}
 
 uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -2080,9 +2818,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast90;
-          xfer += iprot->readI32(ecast90);
-          this->type = (ScanType::type)ecast90;
+          int32_t ecast122;
+          xfer += iprot->readI32(ecast122);
+          this->type = (ScanType::type)ecast122;
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2090,9 +2828,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 7:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast91;
-          xfer += iprot->readI32(ecast91);
-          this->state = (ScanState::type)ecast91;
+          int32_t ecast123;
+          xfer += iprot->readI32(ecast123);
+          this->state = (ScanState::type)ecast123;
           this->__isset.state = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2110,14 +2848,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->columns.clear();
-            uint32_t _size92;
-            ::apache::thrift::protocol::TType _etype95;
-            xfer += iprot->readListBegin(_etype95, _size92);
-            this->columns.resize(_size92);
-            uint32_t _i96;
-            for (_i96 = 0; _i96 < _size92; ++_i96)
+            uint32_t _size124;
+            ::apache::thrift::protocol::TType _etype127;
+            xfer += iprot->readListBegin(_etype127, _size124);
+            this->columns.resize(_size124);
+            uint32_t _i128;
+            for (_i128 = 0; _i128 < _size124; ++_i128)
             {
-              xfer += this->columns[_i96].read(iprot);
+              xfer += this->columns[_i128].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -2130,14 +2868,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size97;
-            ::apache::thrift::protocol::TType _etype100;
-            xfer += iprot->readListBegin(_etype100, _size97);
-            this->iterators.resize(_size97);
-            uint32_t _i101;
-            for (_i101 = 0; _i101 < _size97; ++_i101)
+            uint32_t _size129;
+            ::apache::thrift::protocol::TType _etype132;
+            xfer += iprot->readListBegin(_etype132, _size129);
+            this->iterators.resize(_size129);
+            uint32_t _i133;
+            for (_i133 = 0; _i133 < _size129; ++_i133)
             {
-              xfer += this->iterators[_i101].read(iprot);
+              xfer += this->iterators[_i133].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -2150,14 +2888,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->authorizations.clear();
-            uint32_t _size102;
-            ::apache::thrift::protocol::TType _etype105;
-            xfer += iprot->readListBegin(_etype105, _size102);
-            this->authorizations.resize(_size102);
-            uint32_t _i106;
-            for (_i106 = 0; _i106 < _size102; ++_i106)
+            uint32_t _size134;
+            ::apache::thrift::protocol::TType _etype137;
+            xfer += iprot->readListBegin(_etype137, _size134);
+            this->authorizations.resize(_size134);
+            uint32_t _i138;
+            for (_i138 = 0; _i138 < _size134; ++_i138)
             {
-              xfer += iprot->readBinary(this->authorizations[_i106]);
+              xfer += iprot->readBinary(this->authorizations[_i138]);
             }
             xfer += iprot->readListEnd();
           }
@@ -2180,6 +2918,7 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ActiveScan");
 
   xfer += oprot->writeFieldBegin("client", ::apache::thrift::protocol::T_STRING, 1);
@@ -2217,10 +2956,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 9);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    std::vector<Column> ::const_iterator _iter107;
-    for (_iter107 = this->columns.begin(); _iter107 != this->columns.end(); ++_iter107)
+    std::vector<Column> ::const_iterator _iter139;
+    for (_iter139 = this->columns.begin(); _iter139 != this->columns.end(); ++_iter139)
     {
-      xfer += (*_iter107).write(oprot);
+      xfer += (*_iter139).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2229,10 +2968,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-    std::vector<IteratorSetting> ::const_iterator _iter108;
-    for (_iter108 = this->iterators.begin(); _iter108 != this->iterators.end(); ++_iter108)
+    std::vector<IteratorSetting> ::const_iterator _iter140;
+    for (_iter140 = this->iterators.begin(); _iter140 != this->iterators.end(); ++_iter140)
     {
-      xfer += (*_iter108).write(oprot);
+      xfer += (*_iter140).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2241,10 +2980,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_LIST, 11);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size()));
-    std::vector<std::string> ::const_iterator _iter109;
-    for (_iter109 = this->authorizations.begin(); _iter109 != this->authorizations.end(); ++_iter109)
+    std::vector<std::string> ::const_iterator _iter141;
+    for (_iter141 = this->authorizations.begin(); _iter141 != this->authorizations.end(); ++_iter141)
     {
-      xfer += oprot->writeBinary((*_iter109));
+      xfer += oprot->writeBinary((*_iter141));
     }
     xfer += oprot->writeListEnd();
   }
@@ -2271,11 +3010,100 @@ void swap(ActiveScan &a, ActiveScan &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ActiveCompaction::ascii_fingerprint = "2BB155CC901109464666B6C7E6A8C1A6";
-const uint8_t ActiveCompaction::binary_fingerprint[16] = {0x2B,0xB1,0x55,0xCC,0x90,0x11,0x09,0x46,0x46,0x66,0xB6,0xC7,0xE6,0xA8,0xC1,0xA6};
+ActiveScan::ActiveScan(const ActiveScan& other142) {
+  client = other142.client;
+  user = other142.user;
+  table = other142.table;
+  age = other142.age;
+  idleTime = other142.idleTime;
+  type = other142.type;
+  state = other142.state;
+  extent = other142.extent;
+  columns = other142.columns;
+  iterators = other142.iterators;
+  authorizations = other142.authorizations;
+  __isset = other142.__isset;
+}
+ActiveScan& ActiveScan::operator=(const ActiveScan& other143) {
+  client = other143.client;
+  user = other143.user;
+  table = other143.table;
+  age = other143.age;
+  idleTime = other143.idleTime;
+  type = other143.type;
+  state = other143.state;
+  extent = other143.extent;
+  columns = other143.columns;
+  iterators = other143.iterators;
+  authorizations = other143.authorizations;
+  __isset = other143.__isset;
+  return *this;
+}
+void ActiveScan::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ActiveScan(";
+  out << "client=" << to_string(client);
+  out << ", " << "user=" << to_string(user);
+  out << ", " << "table=" << to_string(table);
+  out << ", " << "age=" << to_string(age);
+  out << ", " << "idleTime=" << to_string(idleTime);
+  out << ", " << "type=" << to_string(type);
+  out << ", " << "state=" << to_string(state);
+  out << ", " << "extent=" << to_string(extent);
+  out << ", " << "columns=" << to_string(columns);
+  out << ", " << "iterators=" << to_string(iterators);
+  out << ", " << "authorizations=" << to_string(authorizations);
+  out << ")";
+}
+
+
+ActiveCompaction::~ActiveCompaction() throw() {
+}
+
+
+void ActiveCompaction::__set_extent(const KeyExtent& val) {
+  this->extent = val;
+}
+
+void ActiveCompaction::__set_age(const int64_t val) {
+  this->age = val;
+}
+
+void ActiveCompaction::__set_inputFiles(const std::vector<std::string> & val) {
+  this->inputFiles = val;
+}
+
+void ActiveCompaction::__set_outputFile(const std::string& val) {
+  this->outputFile = val;
+}
+
+void ActiveCompaction::__set_type(const CompactionType::type val) {
+  this->type = val;
+}
+
+void ActiveCompaction::__set_reason(const CompactionReason::type val) {
+  this->reason = val;
+}
+
+void ActiveCompaction::__set_localityGroup(const std::string& val) {
+  this->localityGroup = val;
+}
+
+void ActiveCompaction::__set_entriesRead(const int64_t val) {
+  this->entriesRead = val;
+}
+
+void ActiveCompaction::__set_entriesWritten(const int64_t val) {
+  this->entriesWritten = val;
+}
+
+void ActiveCompaction::__set_iterators(const std::vector<IteratorSetting> & val) {
+  this->iterators = val;
+}
 
 uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -2314,14 +3142,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->inputFiles.clear();
-            uint32_t _size110;
-            ::apache::thrift::protocol::TType _etype113;
-            xfer += iprot->readListBegin(_etype113, _size110);
-            this->inputFiles.resize(_size110);
-            uint32_t _i114;
-            for (_i114 = 0; _i114 < _size110; ++_i114)
+            uint32_t _size144;
+            ::apache::thrift::protocol::TType _etype147;
+            xfer += iprot->readListBegin(_etype147, _size144);
+            this->inputFiles.resize(_size144);
+            uint32_t _i148;
+            for (_i148 = 0; _i148 < _size144; ++_i148)
             {
-              xfer += iprot->readString(this->inputFiles[_i114]);
+              xfer += iprot->readString(this->inputFiles[_i148]);
             }
             xfer += iprot->readListEnd();
           }
@@ -2340,9 +3168,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 5:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast115;
-          xfer += iprot->readI32(ecast115);
-          this->type = (CompactionType::type)ecast115;
+          int32_t ecast149;
+          xfer += iprot->readI32(ecast149);
+          this->type = (CompactionType::type)ecast149;
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2350,9 +3178,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast116;
-          xfer += iprot->readI32(ecast116);
-          this->reason = (CompactionReason::type)ecast116;
+          int32_t ecast150;
+          xfer += iprot->readI32(ecast150);
+          this->reason = (CompactionReason::type)ecast150;
           this->__isset.reason = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2386,14 +3214,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size117;
-            ::apache::thrift::protocol::TType _etype120;
-            xfer += iprot->readListBegin(_etype120, _size117);
-            this->iterators.resize(_size117);
-            uint32_t _i121;
-            for (_i121 = 0; _i121 < _size117; ++_i121)
+            uint32_t _size151;
+            ::apache::thrift::protocol::TType _etype154;
+            xfer += iprot->readListBegin(_etype154, _size151);
+            this->iterators.resize(_size151);
+            uint32_t _i155;
+            for (_i155 = 0; _i155 < _size151; ++_i155)
             {
-              xfer += this->iterators[_i121].read(iprot);
+              xfer += this->iterators[_i155].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -2416,6 +3244,7 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("ActiveCompaction");
 
   xfer += oprot->writeFieldBegin("extent", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -2429,10 +3258,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c
   xfer += oprot->writeFieldBegin("inputFiles", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->inputFiles.size()));
-    std::vector<std::string> ::const_iterator _iter122;
-    for (_iter122 = this->inputFiles.begin(); _iter122 != this->inputFiles.end(); ++_iter122)
+    std::vector<std::string> ::const_iterator _iter156;
+    for (_iter156 = this->inputFiles.begin(); _iter156 != this->inputFiles.end(); ++_iter156)
     {
-      xfer += oprot->writeString((*_iter122));
+      xfer += oprot->writeString((*_iter156));
     }
     xfer += oprot->writeListEnd();
   }
@@ -2465,10 +3294,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c
   xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-    std::vector<IteratorSetting> ::const_iterator _iter123;
-    for (_iter123 = this->iterators.begin(); _iter123 != this->iterators.end(); ++_iter123)
+    std::vector<IteratorSetting> ::const_iterator _iter157;
+    for (_iter157 = this->iterators.begin(); _iter157 != this->iterators.end(); ++_iter157)
     {
-      xfer += (*_iter123).write(oprot);
+      xfer += (*_iter157).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2494,11 +3323,78 @@ void swap(ActiveCompaction &a, ActiveCompaction &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* WriterOptions::ascii_fingerprint = "6640C55D2C0D4C8C2E7589456EA0C61A";
-const uint8_t WriterOptions::binary_fingerprint[16] = {0x66,0x40,0xC5,0x5D,0x2C,0x0D,0x4C,0x8C,0x2E,0x75,0x89,0x45,0x6E,0xA0,0xC6,0x1A};
+ActiveCompaction::ActiveCompaction(const ActiveCompaction& other158) {
+  extent = other158.extent;
+  age = other158.age;
+  inputFiles = other158.inputFiles;
+  outputFile = other158.outputFile;
+  type = other158.type;
+  reason = other158.reason;
+  localityGroup = other158.localityGroup;
+  entriesRead = other158.entriesRead;
+  entriesWritten = other158.entriesWritten;
+  iterators = other158.iterators;
+  __isset = other158.__isset;
+}
+ActiveCompaction& ActiveCompaction::operator=(const ActiveCompaction& other159) {
+  extent = other159.extent;
+  age = other159.age;
+  inputFiles = other159.inputFiles;
+  outputFile = other159.outputFile;
+  type = other159.type;
+  reason = other159.reason;
+  localityGroup = other159.localityGroup;
+  entriesRead = other159.entriesRead;
+  entriesWritten = other159.entriesWritten;
+  iterators = other159.iterators;
+  __isset = other159.__isset;
+  return *this;
+}
+void ActiveCompaction::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "ActiveCompaction(";
+  out << "extent=" << to_string(extent);
+  out << ", " << "age=" << to_string(age);
+  out << ", " << "inputFiles=" << to_string(inputFiles);
+  out << ", " << "outputFile=" << to_string(outputFile);
+  out << ", " << "type=" << to_string(type);
+  out << ", " << "reason=" << to_string(reason);
+  out << ", " << "localityGroup=" << to_string(localityGroup);
+  out << ", " << "entriesRead=" << to_string(entriesRead);
+  out << ", " << "entriesWritten=" << to_string(entriesWritten);
+  out << ", " << "iterators=" << to_string(iterators);
+  out << ")";
+}
+
+
+WriterOptions::~WriterOptions() throw() {
+}
+
+
+void WriterOptions::__set_maxMemory(const int64_t val) {
+  this->maxMemory = val;
+}
+
+void WriterOptions::__set_latencyMs(const int64_t val) {
+  this->latencyMs = val;
+}
+
+void WriterOptions::__set_timeoutMs(const int64_t val) {
+  this->timeoutMs = val;
+}
+
+void WriterOptions::__set_threads(const int32_t val) {
+  this->threads = val;
+}
+
+void WriterOptions::__set_durability(const Durability::type val) {
+  this->durability = val;
+__isset.durability = true;
+}
 
 uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -2551,9 +3447,9 @@ uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 5:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast124;
-          xfer += iprot->readI32(ecast124);
-          this->durability = (Durability::type)ecast124;
+          int32_t ecast160;
+          xfer += iprot->readI32(ecast160);
+          this->durability = (Durability::type)ecast160;
           this->__isset.durability = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2573,6 +3469,7 @@ uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t WriterOptions::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("WriterOptions");
 
   xfer += oprot->writeFieldBegin("maxMemory", ::apache::thrift::protocol::T_I64, 1);
@@ -2611,11 +3508,50 @@ void swap(WriterOptions &a, WriterOptions &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* CompactionStrategyConfig::ascii_fingerprint = "F7C641917C22B35AE581CCD54910B00D";
-const uint8_t CompactionStrategyConfig::binary_fingerprint[16] = {0xF7,0xC6,0x41,0x91,0x7C,0x22,0xB3,0x5A,0xE5,0x81,0xCC,0xD5,0x49,0x10,0xB0,0x0D};
+WriterOptions::WriterOptions(const WriterOptions& other161) {
+  maxMemory = other161.maxMemory;
+  latencyMs = other161.latencyMs;
+  timeoutMs = other161.timeoutMs;
+  threads = other161.threads;
+  durability = other161.durability;
+  __isset = other161.__isset;
+}
+WriterOptions& WriterOptions::operator=(const WriterOptions& other162) {
+  maxMemory = other162.maxMemory;
+  latencyMs = other162.latencyMs;
+  timeoutMs = other162.timeoutMs;
+  threads = other162.threads;
+  durability = other162.durability;
+  __isset = other162.__isset;
+  return *this;
+}
+void WriterOptions::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WriterOptions(";
+  out << "maxMemory=" << to_string(maxMemory);
+  out << ", " << "latencyMs=" << to_string(latencyMs);
+  out << ", " << "timeoutMs=" << to_string(timeoutMs);
+  out << ", " << "threads=" << to_string(threads);
+  out << ", " << "durability="; (__isset.durability ? (out << to_string(durability)) : (out << "<null>"));
+  out << ")";
+}
+
+
+CompactionStrategyConfig::~CompactionStrategyConfig() throw() {
+}
+
+
+void CompactionStrategyConfig::__set_className(const std::string& val) {
+  this->className = val;
+}
+
+void CompactionStrategyConfig::__set_options(const std::map<std::string, std::string> & val) {
+  this->options = val;
+}
 
 uint32_t CompactionStrategyConfig::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -2646,17 +3582,17 @@ uint32_t CompactionStrategyConfig::read(::apache::thrift::protocol::TProtocol* i
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->options.clear();
-            uint32_t _size125;
-            ::apache::thrift::protocol::TType _ktype126;
-            ::apache::thrift::protocol::TType _vtype127;
-            xfer += iprot->readMapBegin(_ktype126, _vtype127, _size125);
-            uint32_t _i129;
-            for (_i129 = 0; _i129 < _size125; ++_i129)
+            uint32_t _size163;
+            ::apache::thrift::protocol::TType _ktype164;
+            ::apache::thrift::protocol::TType _vtype165;
+            xfer += iprot->readMapBegin(_ktype164, _vtype165, _size163);
+            uint32_t _i167;
+            for (_i167 = 0; _i167 < _size163; ++_i167)
             {
-              std::string _key130;
-              xfer += iprot->readString(_key130);
-              std::string& _val131 = this->options[_key130];
-              xfer += iprot->readString(_val131);
+              std::string _key168;
+              xfer += iprot->readString(_key168);
+              std::string& _val169 = this->options[_key168];
+              xfer += iprot->readString(_val169);
             }
             xfer += iprot->readMapEnd();
           }
@@ -2679,6 +3615,7 @@ uint32_t CompactionStrategyConfig::read(::apache::thrift::protocol::TProtocol* i
 
 uint32_t CompactionStrategyConfig::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("CompactionStrategyConfig");
 
   xfer += oprot->writeFieldBegin("className", ::apache::thrift::protocol::T_STRING, 1);
@@ -2688,11 +3625,11 @@ uint32_t CompactionStrategyConfig::write(::apache::thrift::protocol::TProtocol*
   xfer += oprot->writeFieldBegin("options", ::apache::thrift::protocol::T_MAP, 2);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->options.size()));
-    std::map<std::string, std::string> ::const_iterator _iter132;
-    for (_iter132 = this->options.begin(); _iter132 != this->options.end(); ++_iter132)
+    std::map<std::string, std::string> ::const_iterator _iter170;
+    for (_iter170 = this->options.begin(); _iter170 != this->options.end(); ++_iter170)
     {
-      xfer += oprot->writeString(_iter132->first);
-      xfer += oprot->writeString(_iter132->second);
+      xfer += oprot->writeString(_iter170->first);
+      xfer += oprot->writeString(_iter170->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -2710,11 +3647,37 @@ void swap(CompactionStrategyConfig &a, CompactionStrategyConfig &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* UnknownScanner::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
-const uint8_t UnknownScanner::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+CompactionStrategyConfig::CompactionStrategyConfig(const CompactionStrategyConfig& other171) {
+  className = other171.className;
+  options = other171.options;
+  __isset = other171.__isset;
+}
+CompactionStrategyConfig& CompactionStrategyConfig::operator=(const CompactionStrategyConfig& other172) {
+  className = other172.className;
+  options = other172.options;
+  __isset = other172.__isset;
+  return *this;
+}
+void CompactionStrategyConfig::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "CompactionStrategyConfig(";
+  out << "className=" << to_string(className);
+  out << ", " << "options=" << to_string(options);
+  out << ")";
+}
+
+
+UnknownScanner::~UnknownScanner() throw() {
+}
+
+
+void UnknownScanner::__set_msg(const std::string& val) {
+  this->msg = val;
+}
 
 uint32_t UnknownScanner::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -2755,6 +3718,7 @@ uint32_t UnknownScanner::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t UnknownScanner::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
   xfer += oprot->writeStructBegin("UnknownScanner");
 
   xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1);
@@ -2772,11 +3736,45 @@ void swap(UnknownScanner &a, UnknownScanner &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* UnknownWriter::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
-const uint8_t UnknownWriter::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+UnknownScanner::UnknownScanner(const UnknownScanner& other173) : TException() {
+  msg = other173.msg;
+  __isset = other173.__isset;
+}
+UnknownScanner& UnknownScanner::operator=(const UnknownScanner& other174) {
+  msg = other174.msg;
+  __isset = other174.__isset;
+  return *this;
+}
+void UnknownScanner::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "UnknownScanner(";
+  out << "msg=" << to_string(msg);
+  out << ")";
+}
+
+const char* UnknownScanner::what() const throw() {
+  try {
+    std::stringstream ss;
+    ss << "TException - service has thrown: " << *this;
+    this->thriftTExceptionMessageHolder_ = ss.str();
+    return this->thriftTExceptionMessageHolder_.c_str();
+  } catch (const std::exception&) {
+    return "TException - service has thrown: UnknownScanner";
+  }
+}
+
+
+UnknownWriter::~UnknownWriter() throw() {
+}
+
+
+void UnknownWriter::__set_msg(const std::string& val) {
+  this->msg = val;
+}
 
 uint32_t UnknownWriter::read(::apache::thrift::protocol::TProtocol* iprot) {
 
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -2817,6 +3815,7 @@ uint32_t UnknownWriter::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t UnknownWriter::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*op

<TRUNCATED>

Mime
View raw message