accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From e..@apache.org
Subject [06/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:11 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3af75fc6/proxy/src/main/cpp/proxy_types.h
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/proxy_types.h b/proxy/src/main/cpp/proxy_types.h
index 569de88..f7cce4c 100644
--- a/proxy/src/main/cpp/proxy_types.h
+++ b/proxy/src/main/cpp/proxy_types.h
@@ -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,8 @@
 #ifndef proxy_TYPES_H
 #define proxy_TYPES_H
 
+#include <iosfwd>
+
 #include <thrift/Thrift.h>
 #include <thrift/TApplicationException.h>
 #include <thrift/protocol/TProtocol.h>
@@ -159,26 +161,80 @@ struct TimeType {
 
 extern const std::map<int, const char*> _TimeType_VALUES_TO_NAMES;
 
+class Key;
+
+class ColumnUpdate;
+
+class DiskUsage;
+
+class KeyValue;
+
+class ScanResult;
+
+class Range;
+
+class ScanColumn;
+
+class IteratorSetting;
+
+class ScanOptions;
+
+class BatchScanOptions;
+
+class KeyValueAndPeek;
+
+class KeyExtent;
+
+class Column;
+
+class Condition;
+
+class ConditionalUpdates;
+
+class ConditionalWriterOptions;
+
+class ActiveScan;
+
+class ActiveCompaction;
+
+class WriterOptions;
+
+class CompactionStrategyConfig;
+
+class UnknownScanner;
+
+class UnknownWriter;
+
+class NoMoreEntriesException;
+
+class AccumuloException;
+
+class AccumuloSecurityException;
+
+class TableNotFoundException;
+
+class TableExistsException;
+
+class MutationsRejectedException;
+
 typedef struct _Key__isset {
   _Key__isset() : row(false), colFamily(false), colQualifier(false), colVisibility(false), timestamp(true) {}
-  bool row;
-  bool colFamily;
-  bool colQualifier;
-  bool colVisibility;
-  bool timestamp;
+  bool row :1;
+  bool colFamily :1;
+  bool colQualifier :1;
+  bool colVisibility :1;
+  bool timestamp :1;
 } _Key__isset;
 
 class Key {
  public:
 
-  static const char* ascii_fingerprint; // = "91151A432E03F5E8564877B5194B48E2";
-  static const uint8_t binary_fingerprint[16]; // = {0x91,0x15,0x1A,0x43,0x2E,0x03,0xF5,0xE8,0x56,0x48,0x77,0xB5,0x19,0x4B,0x48,0xE2};
-
+  Key(const Key&);
+  Key& operator=(const Key&);
   Key() : row(), colFamily(), colQualifier(), colVisibility(), timestamp(9223372036854775807LL) {
   }
 
-  virtual ~Key() throw() {}
-
+  virtual ~Key() throw();
   std::string row;
   std::string colFamily;
   std::string colQualifier;
@@ -187,26 +243,15 @@ class Key {
 
   _Key__isset __isset;
 
-  void __set_row(const std::string& val) {
-    row = val;
-  }
+  void __set_row(const std::string& val);
 
-  void __set_colFamily(const std::string& val) {
-    colFamily = val;
-  }
+  void __set_colFamily(const std::string& val);
 
-  void __set_colQualifier(const std::string& val) {
-    colQualifier = val;
-  }
+  void __set_colQualifier(const std::string& val);
 
-  void __set_colVisibility(const std::string& val) {
-    colVisibility = val;
-  }
+  void __set_colVisibility(const std::string& val);
 
-  void __set_timestamp(const int64_t val) {
-    timestamp = val;
-    __isset.timestamp = true;
-  }
+  void __set_timestamp(const int64_t val);
 
   bool operator == (const Key & rhs) const
   {
@@ -233,31 +278,36 @@ class Key {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(Key &a, Key &b);
 
+inline std::ostream& operator<<(std::ostream& out, const Key& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ColumnUpdate__isset {
   _ColumnUpdate__isset() : colFamily(false), colQualifier(false), colVisibility(false), timestamp(false), value(false), deleteCell(false) {}
-  bool colFamily;
-  bool colQualifier;
-  bool colVisibility;
-  bool timestamp;
-  bool value;
-  bool deleteCell;
+  bool colFamily :1;
+  bool colQualifier :1;
+  bool colVisibility :1;
+  bool timestamp :1;
+  bool value :1;
+  bool deleteCell :1;
 } _ColumnUpdate__isset;
 
 class ColumnUpdate {
  public:
 
-  static const char* ascii_fingerprint; // = "65CC1863F7DDC1DE75B9EAF9E2DC0D1F";
-  static const uint8_t binary_fingerprint[16]; // = {0x65,0xCC,0x18,0x63,0xF7,0xDD,0xC1,0xDE,0x75,0xB9,0xEA,0xF9,0xE2,0xDC,0x0D,0x1F};
-
+  ColumnUpdate(const ColumnUpdate&);
+  ColumnUpdate& operator=(const ColumnUpdate&);
   ColumnUpdate() : colFamily(), colQualifier(), colVisibility(), timestamp(0), value(), deleteCell(0) {
   }
 
-  virtual ~ColumnUpdate() throw() {}
-
+  virtual ~ColumnUpdate() throw();
   std::string colFamily;
   std::string colQualifier;
   std::string colVisibility;
@@ -267,33 +317,17 @@ class ColumnUpdate {
 
   _ColumnUpdate__isset __isset;
 
-  void __set_colFamily(const std::string& val) {
-    colFamily = val;
-  }
+  void __set_colFamily(const std::string& val);
 
-  void __set_colQualifier(const std::string& val) {
-    colQualifier = val;
-  }
+  void __set_colQualifier(const std::string& val);
 
-  void __set_colVisibility(const std::string& val) {
-    colVisibility = val;
-    __isset.colVisibility = true;
-  }
+  void __set_colVisibility(const std::string& val);
 
-  void __set_timestamp(const int64_t val) {
-    timestamp = val;
-    __isset.timestamp = true;
-  }
+  void __set_timestamp(const int64_t val);
 
-  void __set_value(const std::string& val) {
-    value = val;
-    __isset.value = true;
-  }
+  void __set_value(const std::string& val);
 
-  void __set_deleteCell(const bool val) {
-    deleteCell = val;
-    __isset.deleteCell = true;
-  }
+  void __set_deleteCell(const bool val);
 
   bool operator == (const ColumnUpdate & rhs) const
   {
@@ -328,39 +362,40 @@ class ColumnUpdate {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ColumnUpdate &a, ColumnUpdate &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ColumnUpdate& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _DiskUsage__isset {
   _DiskUsage__isset() : tables(false), usage(false) {}
-  bool tables;
-  bool usage;
+  bool tables :1;
+  bool usage :1;
 } _DiskUsage__isset;
 
 class DiskUsage {
  public:
 
-  static const char* ascii_fingerprint; // = "D26F4F5E2867D41CF7E0391263932D6B";
-  static const uint8_t binary_fingerprint[16]; // = {0xD2,0x6F,0x4F,0x5E,0x28,0x67,0xD4,0x1C,0xF7,0xE0,0x39,0x12,0x63,0x93,0x2D,0x6B};
-
+  DiskUsage(const DiskUsage&);
+  DiskUsage& operator=(const DiskUsage&);
   DiskUsage() : usage(0) {
   }
 
-  virtual ~DiskUsage() throw() {}
-
+  virtual ~DiskUsage() throw();
   std::vector<std::string>  tables;
   int64_t usage;
 
   _DiskUsage__isset __isset;
 
-  void __set_tables(const std::vector<std::string> & val) {
-    tables = val;
-  }
+  void __set_tables(const std::vector<std::string> & val);
 
-  void __set_usage(const int64_t val) {
-    usage = val;
-  }
+  void __set_usage(const int64_t val);
 
   bool operator == (const DiskUsage & rhs) const
   {
@@ -379,39 +414,40 @@ class DiskUsage {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(DiskUsage &a, DiskUsage &b);
 
+inline std::ostream& operator<<(std::ostream& out, const DiskUsage& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _KeyValue__isset {
   _KeyValue__isset() : key(false), value(false) {}
-  bool key;
-  bool value;
+  bool key :1;
+  bool value :1;
 } _KeyValue__isset;
 
 class KeyValue {
  public:
 
-  static const char* ascii_fingerprint; // = "0D0CA44F233F983E00E94228C31ABBD4";
-  static const uint8_t binary_fingerprint[16]; // = {0x0D,0x0C,0xA4,0x4F,0x23,0x3F,0x98,0x3E,0x00,0xE9,0x42,0x28,0xC3,0x1A,0xBB,0xD4};
-
+  KeyValue(const KeyValue&);
+  KeyValue& operator=(const KeyValue&);
   KeyValue() : value() {
   }
 
-  virtual ~KeyValue() throw() {}
-
+  virtual ~KeyValue() throw();
   Key key;
   std::string value;
 
   _KeyValue__isset __isset;
 
-  void __set_key(const Key& val) {
-    key = val;
-  }
+  void __set_key(const Key& val);
 
-  void __set_value(const std::string& val) {
-    value = val;
-  }
+  void __set_value(const std::string& val);
 
   bool operator == (const KeyValue & rhs) const
   {
@@ -430,39 +466,40 @@ class KeyValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(KeyValue &a, KeyValue &b);
 
+inline std::ostream& operator<<(std::ostream& out, const KeyValue& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ScanResult__isset {
   _ScanResult__isset() : results(false), more(false) {}
-  bool results;
-  bool more;
+  bool results :1;
+  bool more :1;
 } _ScanResult__isset;
 
 class ScanResult {
  public:
 
-  static const char* ascii_fingerprint; // = "684A3FCA76EA202FE071A17F8B510E7A";
-  static const uint8_t binary_fingerprint[16]; // = {0x68,0x4A,0x3F,0xCA,0x76,0xEA,0x20,0x2F,0xE0,0x71,0xA1,0x7F,0x8B,0x51,0x0E,0x7A};
-
+  ScanResult(const ScanResult&);
+  ScanResult& operator=(const ScanResult&);
   ScanResult() : more(0) {
   }
 
-  virtual ~ScanResult() throw() {}
-
+  virtual ~ScanResult() throw();
   std::vector<KeyValue>  results;
   bool more;
 
   _ScanResult__isset __isset;
 
-  void __set_results(const std::vector<KeyValue> & val) {
-    results = val;
-  }
+  void __set_results(const std::vector<KeyValue> & val);
 
-  void __set_more(const bool val) {
-    more = val;
-  }
+  void __set_more(const bool val);
 
   bool operator == (const ScanResult & rhs) const
   {
@@ -481,29 +518,34 @@ class ScanResult {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ScanResult &a, ScanResult &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ScanResult& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _Range__isset {
   _Range__isset() : start(false), startInclusive(false), stop(false), stopInclusive(false) {}
-  bool start;
-  bool startInclusive;
-  bool stop;
-  bool stopInclusive;
+  bool start :1;
+  bool startInclusive :1;
+  bool stop :1;
+  bool stopInclusive :1;
 } _Range__isset;
 
 class Range {
  public:
 
-  static const char* ascii_fingerprint; // = "84C5BA8DB718E60BFBF3F83867647B45";
-  static const uint8_t binary_fingerprint[16]; // = {0x84,0xC5,0xBA,0x8D,0xB7,0x18,0xE6,0x0B,0xFB,0xF3,0xF8,0x38,0x67,0x64,0x7B,0x45};
-
+  Range(const Range&);
+  Range& operator=(const Range&);
   Range() : startInclusive(0), stopInclusive(0) {
   }
 
-  virtual ~Range() throw() {}
-
+  virtual ~Range() throw();
   Key start;
   bool startInclusive;
   Key stop;
@@ -511,21 +553,13 @@ class Range {
 
   _Range__isset __isset;
 
-  void __set_start(const Key& val) {
-    start = val;
-  }
+  void __set_start(const Key& val);
 
-  void __set_startInclusive(const bool val) {
-    startInclusive = val;
-  }
+  void __set_startInclusive(const bool val);
 
-  void __set_stop(const Key& val) {
-    stop = val;
-  }
+  void __set_stop(const Key& val);
 
-  void __set_stopInclusive(const bool val) {
-    stopInclusive = val;
-  }
+  void __set_stopInclusive(const bool val);
 
   bool operator == (const Range & rhs) const
   {
@@ -548,40 +582,40 @@ class Range {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(Range &a, Range &b);
 
+inline std::ostream& operator<<(std::ostream& out, const Range& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ScanColumn__isset {
   _ScanColumn__isset() : colFamily(false), colQualifier(false) {}
-  bool colFamily;
-  bool colQualifier;
+  bool colFamily :1;
+  bool colQualifier :1;
 } _ScanColumn__isset;
 
 class ScanColumn {
  public:
 
-  static const char* ascii_fingerprint; // = "5B708A954C550ECA9C1A49D3C5CAFAB9";
-  static const uint8_t binary_fingerprint[16]; // = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
-
+  ScanColumn(const ScanColumn&);
+  ScanColumn& operator=(const ScanColumn&);
   ScanColumn() : colFamily(), colQualifier() {
   }
 
-  virtual ~ScanColumn() throw() {}
-
+  virtual ~ScanColumn() throw();
   std::string colFamily;
   std::string colQualifier;
 
   _ScanColumn__isset __isset;
 
-  void __set_colFamily(const std::string& val) {
-    colFamily = val;
-  }
+  void __set_colFamily(const std::string& val);
 
-  void __set_colQualifier(const std::string& val) {
-    colQualifier = val;
-    __isset.colQualifier = true;
-  }
+  void __set_colQualifier(const std::string& val);
 
   bool operator == (const ScanColumn & rhs) const
   {
@@ -602,29 +636,34 @@ class ScanColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ScanColumn &a, ScanColumn &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ScanColumn& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _IteratorSetting__isset {
   _IteratorSetting__isset() : priority(false), name(false), iteratorClass(false), properties(false) {}
-  bool priority;
-  bool name;
-  bool iteratorClass;
-  bool properties;
+  bool priority :1;
+  bool name :1;
+  bool iteratorClass :1;
+  bool properties :1;
 } _IteratorSetting__isset;
 
 class IteratorSetting {
  public:
 
-  static const char* ascii_fingerprint; // = "985C857916964E43205EAC92A157CB4E";
-  static const uint8_t binary_fingerprint[16]; // = {0x98,0x5C,0x85,0x79,0x16,0x96,0x4E,0x43,0x20,0x5E,0xAC,0x92,0xA1,0x57,0xCB,0x4E};
-
+  IteratorSetting(const IteratorSetting&);
+  IteratorSetting& operator=(const IteratorSetting&);
   IteratorSetting() : priority(0), name(), iteratorClass() {
   }
 
-  virtual ~IteratorSetting() throw() {}
-
+  virtual ~IteratorSetting() throw();
   int32_t priority;
   std::string name;
   std::string iteratorClass;
@@ -632,21 +671,13 @@ class IteratorSetting {
 
   _IteratorSetting__isset __isset;
 
-  void __set_priority(const int32_t val) {
-    priority = val;
-  }
+  void __set_priority(const int32_t val);
 
-  void __set_name(const std::string& val) {
-    name = val;
-  }
+  void __set_name(const std::string& val);
 
-  void __set_iteratorClass(const std::string& val) {
-    iteratorClass = val;
-  }
+  void __set_iteratorClass(const std::string& val);
 
-  void __set_properties(const std::map<std::string, std::string> & val) {
-    properties = val;
-  }
+  void __set_properties(const std::map<std::string, std::string> & val);
 
   bool operator == (const IteratorSetting & rhs) const
   {
@@ -669,30 +700,35 @@ class IteratorSetting {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(IteratorSetting &a, IteratorSetting &b);
 
+inline std::ostream& operator<<(std::ostream& out, const IteratorSetting& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ScanOptions__isset {
   _ScanOptions__isset() : authorizations(false), range(false), columns(false), iterators(false), bufferSize(false) {}
-  bool authorizations;
-  bool range;
-  bool columns;
-  bool iterators;
-  bool bufferSize;
+  bool authorizations :1;
+  bool range :1;
+  bool columns :1;
+  bool iterators :1;
+  bool bufferSize :1;
 } _ScanOptions__isset;
 
 class ScanOptions {
  public:
 
-  static const char* ascii_fingerprint; // = "3D87D0CD05FA62E15880C4D2C595907C";
-  static const uint8_t binary_fingerprint[16]; // = {0x3D,0x87,0xD0,0xCD,0x05,0xFA,0x62,0xE1,0x58,0x80,0xC4,0xD2,0xC5,0x95,0x90,0x7C};
-
+  ScanOptions(const ScanOptions&);
+  ScanOptions& operator=(const ScanOptions&);
   ScanOptions() : bufferSize(0) {
   }
 
-  virtual ~ScanOptions() throw() {}
-
+  virtual ~ScanOptions() throw();
   std::set<std::string>  authorizations;
   Range range;
   std::vector<ScanColumn>  columns;
@@ -701,30 +737,15 @@ class ScanOptions {
 
   _ScanOptions__isset __isset;
 
-  void __set_authorizations(const std::set<std::string> & val) {
-    authorizations = val;
-    __isset.authorizations = true;
-  }
+  void __set_authorizations(const std::set<std::string> & val);
 
-  void __set_range(const Range& val) {
-    range = val;
-    __isset.range = true;
-  }
+  void __set_range(const Range& val);
 
-  void __set_columns(const std::vector<ScanColumn> & val) {
-    columns = val;
-    __isset.columns = true;
-  }
+  void __set_columns(const std::vector<ScanColumn> & val);
 
-  void __set_iterators(const std::vector<IteratorSetting> & val) {
-    iterators = val;
-    __isset.iterators = true;
-  }
+  void __set_iterators(const std::vector<IteratorSetting> & val);
 
-  void __set_bufferSize(const int32_t val) {
-    bufferSize = val;
-    __isset.bufferSize = true;
-  }
+  void __set_bufferSize(const int32_t val);
 
   bool operator == (const ScanOptions & rhs) const
   {
@@ -759,30 +780,35 @@ class ScanOptions {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ScanOptions &a, ScanOptions &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ScanOptions& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _BatchScanOptions__isset {
   _BatchScanOptions__isset() : authorizations(false), ranges(false), columns(false), iterators(false), threads(false) {}
-  bool authorizations;
-  bool ranges;
-  bool columns;
-  bool iterators;
-  bool threads;
+  bool authorizations :1;
+  bool ranges :1;
+  bool columns :1;
+  bool iterators :1;
+  bool threads :1;
 } _BatchScanOptions__isset;
 
 class BatchScanOptions {
  public:
 
-  static const char* ascii_fingerprint; // = "6ADFA1FBE31B1220D2C103284E002308";
-  static const uint8_t binary_fingerprint[16]; // = {0x6A,0xDF,0xA1,0xFB,0xE3,0x1B,0x12,0x20,0xD2,0xC1,0x03,0x28,0x4E,0x00,0x23,0x08};
-
+  BatchScanOptions(const BatchScanOptions&);
+  BatchScanOptions& operator=(const BatchScanOptions&);
   BatchScanOptions() : threads(0) {
   }
 
-  virtual ~BatchScanOptions() throw() {}
-
+  virtual ~BatchScanOptions() throw();
   std::set<std::string>  authorizations;
   std::vector<Range>  ranges;
   std::vector<ScanColumn>  columns;
@@ -791,30 +817,15 @@ class BatchScanOptions {
 
   _BatchScanOptions__isset __isset;
 
-  void __set_authorizations(const std::set<std::string> & val) {
-    authorizations = val;
-    __isset.authorizations = true;
-  }
+  void __set_authorizations(const std::set<std::string> & val);
 
-  void __set_ranges(const std::vector<Range> & val) {
-    ranges = val;
-    __isset.ranges = true;
-  }
+  void __set_ranges(const std::vector<Range> & val);
 
-  void __set_columns(const std::vector<ScanColumn> & val) {
-    columns = val;
-    __isset.columns = true;
-  }
+  void __set_columns(const std::vector<ScanColumn> & val);
 
-  void __set_iterators(const std::vector<IteratorSetting> & val) {
-    iterators = val;
-    __isset.iterators = true;
-  }
+  void __set_iterators(const std::vector<IteratorSetting> & val);
 
-  void __set_threads(const int32_t val) {
-    threads = val;
-    __isset.threads = true;
-  }
+  void __set_threads(const int32_t val);
 
   bool operator == (const BatchScanOptions & rhs) const
   {
@@ -849,39 +860,40 @@ class BatchScanOptions {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(BatchScanOptions &a, BatchScanOptions &b);
 
+inline std::ostream& operator<<(std::ostream& out, const BatchScanOptions& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _KeyValueAndPeek__isset {
   _KeyValueAndPeek__isset() : keyValue(false), hasNext(false) {}
-  bool keyValue;
-  bool hasNext;
+  bool keyValue :1;
+  bool hasNext :1;
 } _KeyValueAndPeek__isset;
 
 class KeyValueAndPeek {
  public:
 
-  static const char* ascii_fingerprint; // = "CBBC6AB9C7EA5E5E748C13F970862FAB";
-  static const uint8_t binary_fingerprint[16]; // = {0xCB,0xBC,0x6A,0xB9,0xC7,0xEA,0x5E,0x5E,0x74,0x8C,0x13,0xF9,0x70,0x86,0x2F,0xAB};
-
+  KeyValueAndPeek(const KeyValueAndPeek&);
+  KeyValueAndPeek& operator=(const KeyValueAndPeek&);
   KeyValueAndPeek() : hasNext(0) {
   }
 
-  virtual ~KeyValueAndPeek() throw() {}
-
+  virtual ~KeyValueAndPeek() throw();
   KeyValue keyValue;
   bool hasNext;
 
   _KeyValueAndPeek__isset __isset;
 
-  void __set_keyValue(const KeyValue& val) {
-    keyValue = val;
-  }
+  void __set_keyValue(const KeyValue& val);
 
-  void __set_hasNext(const bool val) {
-    hasNext = val;
-  }
+  void __set_hasNext(const bool val);
 
   bool operator == (const KeyValueAndPeek & rhs) const
   {
@@ -900,45 +912,44 @@ class KeyValueAndPeek {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(KeyValueAndPeek &a, KeyValueAndPeek &b);
 
+inline std::ostream& operator<<(std::ostream& out, const KeyValueAndPeek& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _KeyExtent__isset {
   _KeyExtent__isset() : tableId(false), endRow(false), prevEndRow(false) {}
-  bool tableId;
-  bool endRow;
-  bool prevEndRow;
+  bool tableId :1;
+  bool endRow :1;
+  bool prevEndRow :1;
 } _KeyExtent__isset;
 
 class KeyExtent {
  public:
 
-  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
-  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
-
+  KeyExtent(const KeyExtent&);
+  KeyExtent& operator=(const KeyExtent&);
   KeyExtent() : tableId(), endRow(), prevEndRow() {
   }
 
-  virtual ~KeyExtent() throw() {}
-
+  virtual ~KeyExtent() throw();
   std::string tableId;
   std::string endRow;
   std::string prevEndRow;
 
   _KeyExtent__isset __isset;
 
-  void __set_tableId(const std::string& val) {
-    tableId = val;
-  }
+  void __set_tableId(const std::string& val);
 
-  void __set_endRow(const std::string& val) {
-    endRow = val;
-  }
+  void __set_endRow(const std::string& val);
 
-  void __set_prevEndRow(const std::string& val) {
-    prevEndRow = val;
-  }
+  void __set_prevEndRow(const std::string& val);
 
   bool operator == (const KeyExtent & rhs) const
   {
@@ -959,45 +970,44 @@ class KeyExtent {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(KeyExtent &a, KeyExtent &b);
 
+inline std::ostream& operator<<(std::ostream& out, const KeyExtent& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _Column__isset {
   _Column__isset() : colFamily(false), colQualifier(false), colVisibility(false) {}
-  bool colFamily;
-  bool colQualifier;
-  bool colVisibility;
+  bool colFamily :1;
+  bool colQualifier :1;
+  bool colVisibility :1;
 } _Column__isset;
 
 class Column {
  public:
 
-  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
-  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
-
+  Column(const Column&);
+  Column& operator=(const Column&);
   Column() : colFamily(), colQualifier(), colVisibility() {
   }
 
-  virtual ~Column() throw() {}
-
+  virtual ~Column() throw();
   std::string colFamily;
   std::string colQualifier;
   std::string colVisibility;
 
   _Column__isset __isset;
 
-  void __set_colFamily(const std::string& val) {
-    colFamily = val;
-  }
+  void __set_colFamily(const std::string& val);
 
-  void __set_colQualifier(const std::string& val) {
-    colQualifier = val;
-  }
+  void __set_colQualifier(const std::string& val);
 
-  void __set_colVisibility(const std::string& val) {
-    colVisibility = val;
-  }
+  void __set_colVisibility(const std::string& val);
 
   bool operator == (const Column & rhs) const
   {
@@ -1018,29 +1028,34 @@ class Column {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(Column &a, Column &b);
 
+inline std::ostream& operator<<(std::ostream& out, const Column& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _Condition__isset {
   _Condition__isset() : column(false), timestamp(false), value(false), iterators(false) {}
-  bool column;
-  bool timestamp;
-  bool value;
-  bool iterators;
+  bool column :1;
+  bool timestamp :1;
+  bool value :1;
+  bool iterators :1;
 } _Condition__isset;
 
 class Condition {
  public:
 
-  static const char* ascii_fingerprint; // = "C4022914C22D89E33B1A46A7D511C58F";
-  static const uint8_t binary_fingerprint[16]; // = {0xC4,0x02,0x29,0x14,0xC2,0x2D,0x89,0xE3,0x3B,0x1A,0x46,0xA7,0xD5,0x11,0xC5,0x8F};
-
+  Condition(const Condition&);
+  Condition& operator=(const Condition&);
   Condition() : timestamp(0), value() {
   }
 
-  virtual ~Condition() throw() {}
-
+  virtual ~Condition() throw();
   Column column;
   int64_t timestamp;
   std::string value;
@@ -1048,24 +1063,13 @@ class Condition {
 
   _Condition__isset __isset;
 
-  void __set_column(const Column& val) {
-    column = val;
-  }
+  void __set_column(const Column& val);
 
-  void __set_timestamp(const int64_t val) {
-    timestamp = val;
-    __isset.timestamp = true;
-  }
+  void __set_timestamp(const int64_t val);
 
-  void __set_value(const std::string& val) {
-    value = val;
-    __isset.value = true;
-  }
+  void __set_value(const std::string& val);
 
-  void __set_iterators(const std::vector<IteratorSetting> & val) {
-    iterators = val;
-    __isset.iterators = true;
-  }
+  void __set_iterators(const std::vector<IteratorSetting> & val);
 
   bool operator == (const Condition & rhs) const
   {
@@ -1094,39 +1098,40 @@ class Condition {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(Condition &a, Condition &b);
 
+inline std::ostream& operator<<(std::ostream& out, const Condition& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ConditionalUpdates__isset {
   _ConditionalUpdates__isset() : conditions(false), updates(false) {}
-  bool conditions;
-  bool updates;
+  bool conditions :1;
+  bool updates :1;
 } _ConditionalUpdates__isset;
 
 class ConditionalUpdates {
  public:
 
-  static const char* ascii_fingerprint; // = "1C1808872D1A8E04F114974ADD77F356";
-  static const uint8_t binary_fingerprint[16]; // = {0x1C,0x18,0x08,0x87,0x2D,0x1A,0x8E,0x04,0xF1,0x14,0x97,0x4A,0xDD,0x77,0xF3,0x56};
-
+  ConditionalUpdates(const ConditionalUpdates&);
+  ConditionalUpdates& operator=(const ConditionalUpdates&);
   ConditionalUpdates() {
   }
 
-  virtual ~ConditionalUpdates() throw() {}
-
+  virtual ~ConditionalUpdates() throw();
   std::vector<Condition>  conditions;
   std::vector<ColumnUpdate>  updates;
 
   _ConditionalUpdates__isset __isset;
 
-  void __set_conditions(const std::vector<Condition> & val) {
-    conditions = val;
-  }
+  void __set_conditions(const std::vector<Condition> & val);
 
-  void __set_updates(const std::vector<ColumnUpdate> & val) {
-    updates = val;
-  }
+  void __set_updates(const std::vector<ColumnUpdate> & val);
 
   bool operator == (const ConditionalUpdates & rhs) const
   {
@@ -1145,30 +1150,35 @@ class ConditionalUpdates {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ConditionalUpdates &a, ConditionalUpdates &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ConditionalUpdates& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ConditionalWriterOptions__isset {
   _ConditionalWriterOptions__isset() : maxMemory(false), timeoutMs(false), threads(false), authorizations(false), durability(false) {}
-  bool maxMemory;
-  bool timeoutMs;
-  bool threads;
-  bool authorizations;
-  bool durability;
+  bool maxMemory :1;
+  bool timeoutMs :1;
+  bool threads :1;
+  bool authorizations :1;
+  bool durability :1;
 } _ConditionalWriterOptions__isset;
 
 class ConditionalWriterOptions {
  public:
 
-  static const char* ascii_fingerprint; // = "C345C04E84A351638B6EACB741BD600E";
-  static const uint8_t binary_fingerprint[16]; // = {0xC3,0x45,0xC0,0x4E,0x84,0xA3,0x51,0x63,0x8B,0x6E,0xAC,0xB7,0x41,0xBD,0x60,0x0E};
-
+  ConditionalWriterOptions(const ConditionalWriterOptions&);
+  ConditionalWriterOptions& operator=(const ConditionalWriterOptions&);
   ConditionalWriterOptions() : maxMemory(0), timeoutMs(0), threads(0), durability((Durability::type)0) {
   }
 
-  virtual ~ConditionalWriterOptions() throw() {}
-
+  virtual ~ConditionalWriterOptions() throw();
   int64_t maxMemory;
   int64_t timeoutMs;
   int32_t threads;
@@ -1177,30 +1187,15 @@ class ConditionalWriterOptions {
 
   _ConditionalWriterOptions__isset __isset;
 
-  void __set_maxMemory(const int64_t val) {
-    maxMemory = val;
-    __isset.maxMemory = true;
-  }
+  void __set_maxMemory(const int64_t val);
 
-  void __set_timeoutMs(const int64_t val) {
-    timeoutMs = val;
-    __isset.timeoutMs = true;
-  }
+  void __set_timeoutMs(const int64_t val);
 
-  void __set_threads(const int32_t val) {
-    threads = val;
-    __isset.threads = true;
-  }
+  void __set_threads(const int32_t val);
 
-  void __set_authorizations(const std::set<std::string> & val) {
-    authorizations = val;
-    __isset.authorizations = true;
-  }
+  void __set_authorizations(const std::set<std::string> & val);
 
-  void __set_durability(const Durability::type val) {
-    durability = val;
-    __isset.durability = true;
-  }
+  void __set_durability(const Durability::type val);
 
   bool operator == (const ConditionalWriterOptions & rhs) const
   {
@@ -1235,36 +1230,41 @@ class ConditionalWriterOptions {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ConditionalWriterOptions& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ActiveScan__isset {
   _ActiveScan__isset() : client(false), user(false), table(false), age(false), idleTime(false), type(false), state(false), extent(false), columns(false), iterators(false), authorizations(false) {}
-  bool client;
-  bool user;
-  bool table;
-  bool age;
-  bool idleTime;
-  bool type;
-  bool state;
-  bool extent;
-  bool columns;
-  bool iterators;
-  bool authorizations;
+  bool client :1;
+  bool user :1;
+  bool table :1;
+  bool age :1;
+  bool idleTime :1;
+  bool type :1;
+  bool state :1;
+  bool extent :1;
+  bool columns :1;
+  bool iterators :1;
+  bool authorizations :1;
 } _ActiveScan__isset;
 
 class ActiveScan {
  public:
 
-  static const char* ascii_fingerprint; // = "1B97541CB4E900A054266BBBEE61D004";
-  static const uint8_t binary_fingerprint[16]; // = {0x1B,0x97,0x54,0x1C,0xB4,0xE9,0x00,0xA0,0x54,0x26,0x6B,0xBB,0xEE,0x61,0xD0,0x04};
-
+  ActiveScan(const ActiveScan&);
+  ActiveScan& operator=(const ActiveScan&);
   ActiveScan() : client(), user(), table(), age(0), idleTime(0), type((ScanType::type)0), state((ScanState::type)0) {
   }
 
-  virtual ~ActiveScan() throw() {}
-
+  virtual ~ActiveScan() throw();
   std::string client;
   std::string user;
   std::string table;
@@ -1279,49 +1279,27 @@ class ActiveScan {
 
   _ActiveScan__isset __isset;
 
-  void __set_client(const std::string& val) {
-    client = val;
-  }
+  void __set_client(const std::string& val);
 
-  void __set_user(const std::string& val) {
-    user = val;
-  }
+  void __set_user(const std::string& val);
 
-  void __set_table(const std::string& val) {
-    table = val;
-  }
+  void __set_table(const std::string& val);
 
-  void __set_age(const int64_t val) {
-    age = val;
-  }
+  void __set_age(const int64_t val);
 
-  void __set_idleTime(const int64_t val) {
-    idleTime = val;
-  }
+  void __set_idleTime(const int64_t val);
 
-  void __set_type(const ScanType::type val) {
-    type = val;
-  }
+  void __set_type(const ScanType::type val);
 
-  void __set_state(const ScanState::type val) {
-    state = val;
-  }
+  void __set_state(const ScanState::type val);
 
-  void __set_extent(const KeyExtent& val) {
-    extent = val;
-  }
+  void __set_extent(const KeyExtent& val);
 
-  void __set_columns(const std::vector<Column> & val) {
-    columns = val;
-  }
+  void __set_columns(const std::vector<Column> & val);
 
-  void __set_iterators(const std::vector<IteratorSetting> & val) {
-    iterators = val;
-  }
+  void __set_iterators(const std::vector<IteratorSetting> & val);
 
-  void __set_authorizations(const std::vector<std::string> & val) {
-    authorizations = val;
-  }
+  void __set_authorizations(const std::vector<std::string> & val);
 
   bool operator == (const ActiveScan & rhs) const
   {
@@ -1358,35 +1336,40 @@ class ActiveScan {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ActiveScan &a, ActiveScan &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ActiveScan& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _ActiveCompaction__isset {
   _ActiveCompaction__isset() : extent(false), age(false), inputFiles(false), outputFile(false), type(false), reason(false), localityGroup(false), entriesRead(false), entriesWritten(false), iterators(false) {}
-  bool extent;
-  bool age;
-  bool inputFiles;
-  bool outputFile;
-  bool type;
-  bool reason;
-  bool localityGroup;
-  bool entriesRead;
-  bool entriesWritten;
-  bool iterators;
+  bool extent :1;
+  bool age :1;
+  bool inputFiles :1;
+  bool outputFile :1;
+  bool type :1;
+  bool reason :1;
+  bool localityGroup :1;
+  bool entriesRead :1;
+  bool entriesWritten :1;
+  bool iterators :1;
 } _ActiveCompaction__isset;
 
 class ActiveCompaction {
  public:
 
-  static const char* ascii_fingerprint; // = "2BB155CC901109464666B6C7E6A8C1A6";
-  static const uint8_t binary_fingerprint[16]; // = {0x2B,0xB1,0x55,0xCC,0x90,0x11,0x09,0x46,0x46,0x66,0xB6,0xC7,0xE6,0xA8,0xC1,0xA6};
-
+  ActiveCompaction(const ActiveCompaction&);
+  ActiveCompaction& operator=(const ActiveCompaction&);
   ActiveCompaction() : age(0), outputFile(), type((CompactionType::type)0), reason((CompactionReason::type)0), localityGroup(), entriesRead(0), entriesWritten(0) {
   }
 
-  virtual ~ActiveCompaction() throw() {}
-
+  virtual ~ActiveCompaction() throw();
   KeyExtent extent;
   int64_t age;
   std::vector<std::string>  inputFiles;
@@ -1400,45 +1383,25 @@ class ActiveCompaction {
 
   _ActiveCompaction__isset __isset;
 
-  void __set_extent(const KeyExtent& val) {
-    extent = val;
-  }
+  void __set_extent(const KeyExtent& val);
 
-  void __set_age(const int64_t val) {
-    age = val;
-  }
+  void __set_age(const int64_t val);
 
-  void __set_inputFiles(const std::vector<std::string> & val) {
-    inputFiles = val;
-  }
+  void __set_inputFiles(const std::vector<std::string> & val);
 
-  void __set_outputFile(const std::string& val) {
-    outputFile = val;
-  }
+  void __set_outputFile(const std::string& val);
 
-  void __set_type(const CompactionType::type val) {
-    type = val;
-  }
+  void __set_type(const CompactionType::type val);
 
-  void __set_reason(const CompactionReason::type val) {
-    reason = val;
-  }
+  void __set_reason(const CompactionReason::type val);
 
-  void __set_localityGroup(const std::string& val) {
-    localityGroup = val;
-  }
+  void __set_localityGroup(const std::string& val);
 
-  void __set_entriesRead(const int64_t val) {
-    entriesRead = val;
-  }
+  void __set_entriesRead(const int64_t val);
 
-  void __set_entriesWritten(const int64_t val) {
-    entriesWritten = val;
-  }
+  void __set_entriesWritten(const int64_t val);
 
-  void __set_iterators(const std::vector<IteratorSetting> & val) {
-    iterators = val;
-  }
+  void __set_iterators(const std::vector<IteratorSetting> & val);
 
   bool operator == (const ActiveCompaction & rhs) const
   {
@@ -1473,30 +1436,35 @@ class ActiveCompaction {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(ActiveCompaction &a, ActiveCompaction &b);
 
+inline std::ostream& operator<<(std::ostream& out, const ActiveCompaction& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _WriterOptions__isset {
   _WriterOptions__isset() : maxMemory(false), latencyMs(false), timeoutMs(false), threads(false), durability(false) {}
-  bool maxMemory;
-  bool latencyMs;
-  bool timeoutMs;
-  bool threads;
-  bool durability;
+  bool maxMemory :1;
+  bool latencyMs :1;
+  bool timeoutMs :1;
+  bool threads :1;
+  bool durability :1;
 } _WriterOptions__isset;
 
 class WriterOptions {
  public:
 
-  static const char* ascii_fingerprint; // = "6640C55D2C0D4C8C2E7589456EA0C61A";
-  static const uint8_t binary_fingerprint[16]; // = {0x66,0x40,0xC5,0x5D,0x2C,0x0D,0x4C,0x8C,0x2E,0x75,0x89,0x45,0x6E,0xA0,0xC6,0x1A};
-
+  WriterOptions(const WriterOptions&);
+  WriterOptions& operator=(const WriterOptions&);
   WriterOptions() : maxMemory(0), latencyMs(0), timeoutMs(0), threads(0), durability((Durability::type)0) {
   }
 
-  virtual ~WriterOptions() throw() {}
-
+  virtual ~WriterOptions() throw();
   int64_t maxMemory;
   int64_t latencyMs;
   int64_t timeoutMs;
@@ -1505,26 +1473,15 @@ class WriterOptions {
 
   _WriterOptions__isset __isset;
 
-  void __set_maxMemory(const int64_t val) {
-    maxMemory = val;
-  }
+  void __set_maxMemory(const int64_t val);
 
-  void __set_latencyMs(const int64_t val) {
-    latencyMs = val;
-  }
+  void __set_latencyMs(const int64_t val);
 
-  void __set_timeoutMs(const int64_t val) {
-    timeoutMs = val;
-  }
+  void __set_timeoutMs(const int64_t val);
 
-  void __set_threads(const int32_t val) {
-    threads = val;
-  }
+  void __set_threads(const int32_t val);
 
-  void __set_durability(const Durability::type val) {
-    durability = val;
-    __isset.durability = true;
-  }
+  void __set_durability(const Durability::type val);
 
   bool operator == (const WriterOptions & rhs) const
   {
@@ -1551,39 +1508,40 @@ class WriterOptions {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(WriterOptions &a, WriterOptions &b);
 
+inline std::ostream& operator<<(std::ostream& out, const WriterOptions& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _CompactionStrategyConfig__isset {
   _CompactionStrategyConfig__isset() : className(false), options(false) {}
-  bool className;
-  bool options;
+  bool className :1;
+  bool options :1;
 } _CompactionStrategyConfig__isset;
 
 class CompactionStrategyConfig {
  public:
 
-  static const char* ascii_fingerprint; // = "F7C641917C22B35AE581CCD54910B00D";
-  static const uint8_t binary_fingerprint[16]; // = {0xF7,0xC6,0x41,0x91,0x7C,0x22,0xB3,0x5A,0xE5,0x81,0xCC,0xD5,0x49,0x10,0xB0,0x0D};
-
+  CompactionStrategyConfig(const CompactionStrategyConfig&);
+  CompactionStrategyConfig& operator=(const CompactionStrategyConfig&);
   CompactionStrategyConfig() : className() {
   }
 
-  virtual ~CompactionStrategyConfig() throw() {}
-
+  virtual ~CompactionStrategyConfig() throw();
   std::string className;
   std::map<std::string, std::string>  options;
 
   _CompactionStrategyConfig__isset __isset;
 
-  void __set_className(const std::string& val) {
-    className = val;
-  }
+  void __set_className(const std::string& val);
 
-  void __set_options(const std::map<std::string, std::string> & val) {
-    options = val;
-  }
+  void __set_options(const std::map<std::string, std::string> & val);
 
   bool operator == (const CompactionStrategyConfig & rhs) const
   {
@@ -1602,33 +1560,36 @@ class CompactionStrategyConfig {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
 };
 
 void swap(CompactionStrategyConfig &a, CompactionStrategyConfig &b);
 
+inline std::ostream& operator<<(std::ostream& out, const CompactionStrategyConfig& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _UnknownScanner__isset {
   _UnknownScanner__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _UnknownScanner__isset;
 
 class UnknownScanner : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  UnknownScanner(const UnknownScanner&);
+  UnknownScanner& operator=(const UnknownScanner&);
   UnknownScanner() : msg() {
   }
 
-  virtual ~UnknownScanner() throw() {}
-
+  virtual ~UnknownScanner() throw();
   std::string msg;
 
   _UnknownScanner__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const UnknownScanner & rhs) const
   {
@@ -1645,33 +1606,38 @@ class UnknownScanner : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(UnknownScanner &a, UnknownScanner &b);
 
+inline std::ostream& operator<<(std::ostream& out, const UnknownScanner& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _UnknownWriter__isset {
   _UnknownWriter__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _UnknownWriter__isset;
 
 class UnknownWriter : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  UnknownWriter(const UnknownWriter&);
+  UnknownWriter& operator=(const UnknownWriter&);
   UnknownWriter() : msg() {
   }
 
-  virtual ~UnknownWriter() throw() {}
-
+  virtual ~UnknownWriter() throw();
   std::string msg;
 
   _UnknownWriter__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const UnknownWriter & rhs) const
   {
@@ -1688,33 +1654,38 @@ class UnknownWriter : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(UnknownWriter &a, UnknownWriter &b);
 
+inline std::ostream& operator<<(std::ostream& out, const UnknownWriter& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _NoMoreEntriesException__isset {
   _NoMoreEntriesException__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _NoMoreEntriesException__isset;
 
 class NoMoreEntriesException : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  NoMoreEntriesException(const NoMoreEntriesException&);
+  NoMoreEntriesException& operator=(const NoMoreEntriesException&);
   NoMoreEntriesException() : msg() {
   }
 
-  virtual ~NoMoreEntriesException() throw() {}
-
+  virtual ~NoMoreEntriesException() throw();
   std::string msg;
 
   _NoMoreEntriesException__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const NoMoreEntriesException & rhs) const
   {
@@ -1731,33 +1702,38 @@ class NoMoreEntriesException : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(NoMoreEntriesException &a, NoMoreEntriesException &b);
 
+inline std::ostream& operator<<(std::ostream& out, const NoMoreEntriesException& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _AccumuloException__isset {
   _AccumuloException__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _AccumuloException__isset;
 
 class AccumuloException : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  AccumuloException(const AccumuloException&);
+  AccumuloException& operator=(const AccumuloException&);
   AccumuloException() : msg() {
   }
 
-  virtual ~AccumuloException() throw() {}
-
+  virtual ~AccumuloException() throw();
   std::string msg;
 
   _AccumuloException__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const AccumuloException & rhs) const
   {
@@ -1774,33 +1750,38 @@ class AccumuloException : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(AccumuloException &a, AccumuloException &b);
 
+inline std::ostream& operator<<(std::ostream& out, const AccumuloException& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _AccumuloSecurityException__isset {
   _AccumuloSecurityException__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _AccumuloSecurityException__isset;
 
 class AccumuloSecurityException : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  AccumuloSecurityException(const AccumuloSecurityException&);
+  AccumuloSecurityException& operator=(const AccumuloSecurityException&);
   AccumuloSecurityException() : msg() {
   }
 
-  virtual ~AccumuloSecurityException() throw() {}
-
+  virtual ~AccumuloSecurityException() throw();
   std::string msg;
 
   _AccumuloSecurityException__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const AccumuloSecurityException & rhs) const
   {
@@ -1817,33 +1798,38 @@ class AccumuloSecurityException : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(AccumuloSecurityException &a, AccumuloSecurityException &b);
 
+inline std::ostream& operator<<(std::ostream& out, const AccumuloSecurityException& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _TableNotFoundException__isset {
   _TableNotFoundException__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _TableNotFoundException__isset;
 
 class TableNotFoundException : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  TableNotFoundException(const TableNotFoundException&);
+  TableNotFoundException& operator=(const TableNotFoundException&);
   TableNotFoundException() : msg() {
   }
 
-  virtual ~TableNotFoundException() throw() {}
-
+  virtual ~TableNotFoundException() throw();
   std::string msg;
 
   _TableNotFoundException__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const TableNotFoundException & rhs) const
   {
@@ -1860,33 +1846,38 @@ class TableNotFoundException : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(TableNotFoundException &a, TableNotFoundException &b);
 
+inline std::ostream& operator<<(std::ostream& out, const TableNotFoundException& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _TableExistsException__isset {
   _TableExistsException__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _TableExistsException__isset;
 
 class TableExistsException : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  TableExistsException(const TableExistsException&);
+  TableExistsException& operator=(const TableExistsException&);
   TableExistsException() : msg() {
   }
 
-  virtual ~TableExistsException() throw() {}
-
+  virtual ~TableExistsException() throw();
   std::string msg;
 
   _TableExistsException__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const TableExistsException & rhs) const
   {
@@ -1903,33 +1894,38 @@ class TableExistsException : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(TableExistsException &a, TableExistsException &b);
 
+inline std::ostream& operator<<(std::ostream& out, const TableExistsException& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _MutationsRejectedException__isset {
   _MutationsRejectedException__isset() : msg(false) {}
-  bool msg;
+  bool msg :1;
 } _MutationsRejectedException__isset;
 
 class MutationsRejectedException : public ::apache::thrift::TException {
  public:
 
-  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
-  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
-
+  MutationsRejectedException(const MutationsRejectedException&);
+  MutationsRejectedException& operator=(const MutationsRejectedException&);
   MutationsRejectedException() : msg() {
   }
 
-  virtual ~MutationsRejectedException() throw() {}
-
+  virtual ~MutationsRejectedException() throw();
   std::string msg;
 
   _MutationsRejectedException__isset __isset;
 
-  void __set_msg(const std::string& val) {
-    msg = val;
-  }
+  void __set_msg(const std::string& val);
 
   bool operator == (const MutationsRejectedException & rhs) const
   {
@@ -1946,10 +1942,19 @@ class MutationsRejectedException : public ::apache::thrift::TException {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  virtual void printTo(std::ostream& out) const;
+  mutable std::string thriftTExceptionMessageHolder_;
+  const char* what() const throw();
 };
 
 void swap(MutationsRejectedException &a, MutationsRejectedException &b);
 
+inline std::ostream& operator<<(std::ostream& out, const MutationsRejectedException& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 } // namespace
 
 #endif

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3af75fc6/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloException.java
----------------------------------------------------------------------
diff --git a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloException.java b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloException.java
index 724a92e..d633427 100644
--- a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloException.java
+++ b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/AccumuloException.java
@@ -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
@@ -45,10 +45,13 @@ import java.util.Collections;
 import java.util.BitSet;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
+import javax.annotation.Generated;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-@SuppressWarnings({"unchecked", "serial", "rawtypes", "unused"}) public class AccumuloException extends TException implements org.apache.thrift.TBase<AccumuloException, AccumuloException._Fields>, java.io.Serializable, Cloneable, Comparable<AccumuloException> {
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)", date = "2015-12-16")
+public class AccumuloException extends TException implements org.apache.thrift.TBase<AccumuloException, AccumuloException._Fields>, java.io.Serializable, Cloneable, Comparable<AccumuloException> {
   private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("AccumuloException");
 
   private static final org.apache.thrift.protocol.TField MSG_FIELD_DESC = new org.apache.thrift.protocol.TField("msg", org.apache.thrift.protocol.TType.STRING, (short)1);
@@ -243,7 +246,14 @@ import org.slf4j.LoggerFactory;
 
   @Override
   public int hashCode() {
-    return 0;
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_msg = true && (isSetMsg());
+    list.add(present_msg);
+    if (present_msg)
+      list.add(msg);
+
+    return list.hashCode();
   }
 
   @Override


Mime
View raw message