hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sunc...@apache.org
Subject [14/48] hive git commit: HIVE-9152 - Dynamic Partition Pruning [Spark Branch] (Chao Sun, reviewed by Xuefu Zhang and Chengxiang Li)
Date Fri, 17 Jul 2015 19:53:06 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/service/src/gen/thrift/gen-cpp/TCLIService.h
----------------------------------------------------------------------
diff --git a/service/src/gen/thrift/gen-cpp/TCLIService.h b/service/src/gen/thrift/gen-cpp/TCLIService.h
index 030475b..29a9f4a 100644
--- a/service/src/gen/thrift/gen-cpp/TCLIService.h
+++ b/service/src/gen/thrift/gen-cpp/TCLIService.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -124,24 +124,26 @@ class TCLIServiceNull : virtual public TCLIServiceIf {
 
 typedef struct _TCLIService_OpenSession_args__isset {
   _TCLIService_OpenSession_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_OpenSession_args__isset;
 
 class TCLIService_OpenSession_args {
  public:
 
+  static const char* ascii_fingerprint; // = "657FF0677838A57698AD9D58A923940A";
+  static const uint8_t binary_fingerprint[16]; // = {0x65,0x7F,0xF0,0x67,0x78,0x38,0xA5,0x76,0x98,0xAD,0x9D,0x58,0xA9,0x23,0x94,0x0A};
+
+  TCLIService_OpenSession_args(const TCLIService_OpenSession_args&);
+  TCLIService_OpenSession_args& operator=(const TCLIService_OpenSession_args&);
   TCLIService_OpenSession_args() {
   }
 
-  virtual ~TCLIService_OpenSession_args() throw() {}
-
+  virtual ~TCLIService_OpenSession_args() throw();
   TOpenSessionReq req;
 
   _TCLIService_OpenSession_args__isset __isset;
 
-  void __set_req(const TOpenSessionReq& val) {
-    req = val;
-  }
+  void __set_req(const TOpenSessionReq& val);
 
   bool operator == (const TCLIService_OpenSession_args & rhs) const
   {
@@ -158,41 +160,47 @@ class TCLIService_OpenSession_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_OpenSession_args& obj);
 };
 
 
 class TCLIService_OpenSession_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "657FF0677838A57698AD9D58A923940A";
+  static const uint8_t binary_fingerprint[16]; // = {0x65,0x7F,0xF0,0x67,0x78,0x38,0xA5,0x76,0x98,0xAD,0x9D,0x58,0xA9,0x23,0x94,0x0A};
 
-  virtual ~TCLIService_OpenSession_pargs() throw() {}
 
+  virtual ~TCLIService_OpenSession_pargs() throw();
   const TOpenSessionReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_OpenSession_pargs& obj);
 };
 
 typedef struct _TCLIService_OpenSession_result__isset {
   _TCLIService_OpenSession_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_OpenSession_result__isset;
 
 class TCLIService_OpenSession_result {
  public:
 
+  static const char* ascii_fingerprint; // = "C55268D57D6DC6A256619A7DB419699E";
+  static const uint8_t binary_fingerprint[16]; // = {0xC5,0x52,0x68,0xD5,0x7D,0x6D,0xC6,0xA2,0x56,0x61,0x9A,0x7D,0xB4,0x19,0x69,0x9E};
+
+  TCLIService_OpenSession_result(const TCLIService_OpenSession_result&);
+  TCLIService_OpenSession_result& operator=(const TCLIService_OpenSession_result&);
   TCLIService_OpenSession_result() {
   }
 
-  virtual ~TCLIService_OpenSession_result() throw() {}
-
+  virtual ~TCLIService_OpenSession_result() throw();
   TOpenSessionResp success;
 
   _TCLIService_OpenSession_result__isset __isset;
 
-  void __set_success(const TOpenSessionResp& val) {
-    success = val;
-  }
+  void __set_success(const TOpenSessionResp& val);
 
   bool operator == (const TCLIService_OpenSession_result & rhs) const
   {
@@ -209,47 +217,53 @@ class TCLIService_OpenSession_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_OpenSession_result& obj);
 };
 
 typedef struct _TCLIService_OpenSession_presult__isset {
   _TCLIService_OpenSession_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_OpenSession_presult__isset;
 
 class TCLIService_OpenSession_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "C55268D57D6DC6A256619A7DB419699E";
+  static const uint8_t binary_fingerprint[16]; // = {0xC5,0x52,0x68,0xD5,0x7D,0x6D,0xC6,0xA2,0x56,0x61,0x9A,0x7D,0xB4,0x19,0x69,0x9E};
 
-  virtual ~TCLIService_OpenSession_presult() throw() {}
 
+  virtual ~TCLIService_OpenSession_presult() throw();
   TOpenSessionResp* success;
 
   _TCLIService_OpenSession_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_OpenSession_presult& obj);
 };
 
 typedef struct _TCLIService_CloseSession_args__isset {
   _TCLIService_CloseSession_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_CloseSession_args__isset;
 
 class TCLIService_CloseSession_args {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
+
+  TCLIService_CloseSession_args(const TCLIService_CloseSession_args&);
+  TCLIService_CloseSession_args& operator=(const TCLIService_CloseSession_args&);
   TCLIService_CloseSession_args() {
   }
 
-  virtual ~TCLIService_CloseSession_args() throw() {}
-
+  virtual ~TCLIService_CloseSession_args() throw();
   TCloseSessionReq req;
 
   _TCLIService_CloseSession_args__isset __isset;
 
-  void __set_req(const TCloseSessionReq& val) {
-    req = val;
-  }
+  void __set_req(const TCloseSessionReq& val);
 
   bool operator == (const TCLIService_CloseSession_args & rhs) const
   {
@@ -266,41 +280,47 @@ class TCLIService_CloseSession_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseSession_args& obj);
 };
 
 
 class TCLIService_CloseSession_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
 
-  virtual ~TCLIService_CloseSession_pargs() throw() {}
 
+  virtual ~TCLIService_CloseSession_pargs() throw();
   const TCloseSessionReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseSession_pargs& obj);
 };
 
 typedef struct _TCLIService_CloseSession_result__isset {
   _TCLIService_CloseSession_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CloseSession_result__isset;
 
 class TCLIService_CloseSession_result {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
+
+  TCLIService_CloseSession_result(const TCLIService_CloseSession_result&);
+  TCLIService_CloseSession_result& operator=(const TCLIService_CloseSession_result&);
   TCLIService_CloseSession_result() {
   }
 
-  virtual ~TCLIService_CloseSession_result() throw() {}
-
+  virtual ~TCLIService_CloseSession_result() throw();
   TCloseSessionResp success;
 
   _TCLIService_CloseSession_result__isset __isset;
 
-  void __set_success(const TCloseSessionResp& val) {
-    success = val;
-  }
+  void __set_success(const TCloseSessionResp& val);
 
   bool operator == (const TCLIService_CloseSession_result & rhs) const
   {
@@ -317,47 +337,53 @@ class TCLIService_CloseSession_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseSession_result& obj);
 };
 
 typedef struct _TCLIService_CloseSession_presult__isset {
   _TCLIService_CloseSession_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CloseSession_presult__isset;
 
 class TCLIService_CloseSession_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
 
-  virtual ~TCLIService_CloseSession_presult() throw() {}
 
+  virtual ~TCLIService_CloseSession_presult() throw();
   TCloseSessionResp* success;
 
   _TCLIService_CloseSession_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseSession_presult& obj);
 };
 
 typedef struct _TCLIService_GetInfo_args__isset {
   _TCLIService_GetInfo_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetInfo_args__isset;
 
 class TCLIService_GetInfo_args {
  public:
 
+  static const char* ascii_fingerprint; // = "482A174DD6064955A19F28C5395E27FA";
+  static const uint8_t binary_fingerprint[16]; // = {0x48,0x2A,0x17,0x4D,0xD6,0x06,0x49,0x55,0xA1,0x9F,0x28,0xC5,0x39,0x5E,0x27,0xFA};
+
+  TCLIService_GetInfo_args(const TCLIService_GetInfo_args&);
+  TCLIService_GetInfo_args& operator=(const TCLIService_GetInfo_args&);
   TCLIService_GetInfo_args() {
   }
 
-  virtual ~TCLIService_GetInfo_args() throw() {}
-
+  virtual ~TCLIService_GetInfo_args() throw();
   TGetInfoReq req;
 
   _TCLIService_GetInfo_args__isset __isset;
 
-  void __set_req(const TGetInfoReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetInfoReq& val);
 
   bool operator == (const TCLIService_GetInfo_args & rhs) const
   {
@@ -374,41 +400,47 @@ class TCLIService_GetInfo_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetInfo_args& obj);
 };
 
 
 class TCLIService_GetInfo_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "482A174DD6064955A19F28C5395E27FA";
+  static const uint8_t binary_fingerprint[16]; // = {0x48,0x2A,0x17,0x4D,0xD6,0x06,0x49,0x55,0xA1,0x9F,0x28,0xC5,0x39,0x5E,0x27,0xFA};
 
-  virtual ~TCLIService_GetInfo_pargs() throw() {}
 
+  virtual ~TCLIService_GetInfo_pargs() throw();
   const TGetInfoReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetInfo_pargs& obj);
 };
 
 typedef struct _TCLIService_GetInfo_result__isset {
   _TCLIService_GetInfo_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetInfo_result__isset;
 
 class TCLIService_GetInfo_result {
  public:
 
+  static const char* ascii_fingerprint; // = "95AE9E06990A55202EF5D96DABE20D75";
+  static const uint8_t binary_fingerprint[16]; // = {0x95,0xAE,0x9E,0x06,0x99,0x0A,0x55,0x20,0x2E,0xF5,0xD9,0x6D,0xAB,0xE2,0x0D,0x75};
+
+  TCLIService_GetInfo_result(const TCLIService_GetInfo_result&);
+  TCLIService_GetInfo_result& operator=(const TCLIService_GetInfo_result&);
   TCLIService_GetInfo_result() {
   }
 
-  virtual ~TCLIService_GetInfo_result() throw() {}
-
+  virtual ~TCLIService_GetInfo_result() throw();
   TGetInfoResp success;
 
   _TCLIService_GetInfo_result__isset __isset;
 
-  void __set_success(const TGetInfoResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetInfoResp& val);
 
   bool operator == (const TCLIService_GetInfo_result & rhs) const
   {
@@ -425,47 +457,53 @@ class TCLIService_GetInfo_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetInfo_result& obj);
 };
 
 typedef struct _TCLIService_GetInfo_presult__isset {
   _TCLIService_GetInfo_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetInfo_presult__isset;
 
 class TCLIService_GetInfo_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "95AE9E06990A55202EF5D96DABE20D75";
+  static const uint8_t binary_fingerprint[16]; // = {0x95,0xAE,0x9E,0x06,0x99,0x0A,0x55,0x20,0x2E,0xF5,0xD9,0x6D,0xAB,0xE2,0x0D,0x75};
 
-  virtual ~TCLIService_GetInfo_presult() throw() {}
 
+  virtual ~TCLIService_GetInfo_presult() throw();
   TGetInfoResp* success;
 
   _TCLIService_GetInfo_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetInfo_presult& obj);
 };
 
 typedef struct _TCLIService_ExecuteStatement_args__isset {
   _TCLIService_ExecuteStatement_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_ExecuteStatement_args__isset;
 
 class TCLIService_ExecuteStatement_args {
  public:
 
+  static const char* ascii_fingerprint; // = "BD5534ACDA7A523F638927AC476C2173";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0x55,0x34,0xAC,0xDA,0x7A,0x52,0x3F,0x63,0x89,0x27,0xAC,0x47,0x6C,0x21,0x73};
+
+  TCLIService_ExecuteStatement_args(const TCLIService_ExecuteStatement_args&);
+  TCLIService_ExecuteStatement_args& operator=(const TCLIService_ExecuteStatement_args&);
   TCLIService_ExecuteStatement_args() {
   }
 
-  virtual ~TCLIService_ExecuteStatement_args() throw() {}
-
+  virtual ~TCLIService_ExecuteStatement_args() throw();
   TExecuteStatementReq req;
 
   _TCLIService_ExecuteStatement_args__isset __isset;
 
-  void __set_req(const TExecuteStatementReq& val) {
-    req = val;
-  }
+  void __set_req(const TExecuteStatementReq& val);
 
   bool operator == (const TCLIService_ExecuteStatement_args & rhs) const
   {
@@ -482,41 +520,47 @@ class TCLIService_ExecuteStatement_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_ExecuteStatement_args& obj);
 };
 
 
 class TCLIService_ExecuteStatement_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "BD5534ACDA7A523F638927AC476C2173";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0x55,0x34,0xAC,0xDA,0x7A,0x52,0x3F,0x63,0x89,0x27,0xAC,0x47,0x6C,0x21,0x73};
 
-  virtual ~TCLIService_ExecuteStatement_pargs() throw() {}
 
+  virtual ~TCLIService_ExecuteStatement_pargs() throw();
   const TExecuteStatementReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_ExecuteStatement_pargs& obj);
 };
 
 typedef struct _TCLIService_ExecuteStatement_result__isset {
   _TCLIService_ExecuteStatement_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_ExecuteStatement_result__isset;
 
 class TCLIService_ExecuteStatement_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_ExecuteStatement_result(const TCLIService_ExecuteStatement_result&);
+  TCLIService_ExecuteStatement_result& operator=(const TCLIService_ExecuteStatement_result&);
   TCLIService_ExecuteStatement_result() {
   }
 
-  virtual ~TCLIService_ExecuteStatement_result() throw() {}
-
+  virtual ~TCLIService_ExecuteStatement_result() throw();
   TExecuteStatementResp success;
 
   _TCLIService_ExecuteStatement_result__isset __isset;
 
-  void __set_success(const TExecuteStatementResp& val) {
-    success = val;
-  }
+  void __set_success(const TExecuteStatementResp& val);
 
   bool operator == (const TCLIService_ExecuteStatement_result & rhs) const
   {
@@ -533,47 +577,53 @@ class TCLIService_ExecuteStatement_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_ExecuteStatement_result& obj);
 };
 
 typedef struct _TCLIService_ExecuteStatement_presult__isset {
   _TCLIService_ExecuteStatement_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_ExecuteStatement_presult__isset;
 
 class TCLIService_ExecuteStatement_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_ExecuteStatement_presult() throw() {}
 
+  virtual ~TCLIService_ExecuteStatement_presult() throw();
   TExecuteStatementResp* success;
 
   _TCLIService_ExecuteStatement_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_ExecuteStatement_presult& obj);
 };
 
 typedef struct _TCLIService_GetTypeInfo_args__isset {
   _TCLIService_GetTypeInfo_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetTypeInfo_args__isset;
 
 class TCLIService_GetTypeInfo_args {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
+
+  TCLIService_GetTypeInfo_args(const TCLIService_GetTypeInfo_args&);
+  TCLIService_GetTypeInfo_args& operator=(const TCLIService_GetTypeInfo_args&);
   TCLIService_GetTypeInfo_args() {
   }
 
-  virtual ~TCLIService_GetTypeInfo_args() throw() {}
-
+  virtual ~TCLIService_GetTypeInfo_args() throw();
   TGetTypeInfoReq req;
 
   _TCLIService_GetTypeInfo_args__isset __isset;
 
-  void __set_req(const TGetTypeInfoReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetTypeInfoReq& val);
 
   bool operator == (const TCLIService_GetTypeInfo_args & rhs) const
   {
@@ -590,41 +640,47 @@ class TCLIService_GetTypeInfo_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTypeInfo_args& obj);
 };
 
 
 class TCLIService_GetTypeInfo_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
 
-  virtual ~TCLIService_GetTypeInfo_pargs() throw() {}
 
+  virtual ~TCLIService_GetTypeInfo_pargs() throw();
   const TGetTypeInfoReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTypeInfo_pargs& obj);
 };
 
 typedef struct _TCLIService_GetTypeInfo_result__isset {
   _TCLIService_GetTypeInfo_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetTypeInfo_result__isset;
 
 class TCLIService_GetTypeInfo_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_GetTypeInfo_result(const TCLIService_GetTypeInfo_result&);
+  TCLIService_GetTypeInfo_result& operator=(const TCLIService_GetTypeInfo_result&);
   TCLIService_GetTypeInfo_result() {
   }
 
-  virtual ~TCLIService_GetTypeInfo_result() throw() {}
-
+  virtual ~TCLIService_GetTypeInfo_result() throw();
   TGetTypeInfoResp success;
 
   _TCLIService_GetTypeInfo_result__isset __isset;
 
-  void __set_success(const TGetTypeInfoResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetTypeInfoResp& val);
 
   bool operator == (const TCLIService_GetTypeInfo_result & rhs) const
   {
@@ -641,47 +697,53 @@ class TCLIService_GetTypeInfo_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTypeInfo_result& obj);
 };
 
 typedef struct _TCLIService_GetTypeInfo_presult__isset {
   _TCLIService_GetTypeInfo_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetTypeInfo_presult__isset;
 
 class TCLIService_GetTypeInfo_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_GetTypeInfo_presult() throw() {}
 
+  virtual ~TCLIService_GetTypeInfo_presult() throw();
   TGetTypeInfoResp* success;
 
   _TCLIService_GetTypeInfo_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTypeInfo_presult& obj);
 };
 
 typedef struct _TCLIService_GetCatalogs_args__isset {
   _TCLIService_GetCatalogs_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetCatalogs_args__isset;
 
 class TCLIService_GetCatalogs_args {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
+
+  TCLIService_GetCatalogs_args(const TCLIService_GetCatalogs_args&);
+  TCLIService_GetCatalogs_args& operator=(const TCLIService_GetCatalogs_args&);
   TCLIService_GetCatalogs_args() {
   }
 
-  virtual ~TCLIService_GetCatalogs_args() throw() {}
-
+  virtual ~TCLIService_GetCatalogs_args() throw();
   TGetCatalogsReq req;
 
   _TCLIService_GetCatalogs_args__isset __isset;
 
-  void __set_req(const TGetCatalogsReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetCatalogsReq& val);
 
   bool operator == (const TCLIService_GetCatalogs_args & rhs) const
   {
@@ -698,41 +760,47 @@ class TCLIService_GetCatalogs_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetCatalogs_args& obj);
 };
 
 
 class TCLIService_GetCatalogs_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
 
-  virtual ~TCLIService_GetCatalogs_pargs() throw() {}
 
+  virtual ~TCLIService_GetCatalogs_pargs() throw();
   const TGetCatalogsReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetCatalogs_pargs& obj);
 };
 
 typedef struct _TCLIService_GetCatalogs_result__isset {
   _TCLIService_GetCatalogs_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetCatalogs_result__isset;
 
 class TCLIService_GetCatalogs_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_GetCatalogs_result(const TCLIService_GetCatalogs_result&);
+  TCLIService_GetCatalogs_result& operator=(const TCLIService_GetCatalogs_result&);
   TCLIService_GetCatalogs_result() {
   }
 
-  virtual ~TCLIService_GetCatalogs_result() throw() {}
-
+  virtual ~TCLIService_GetCatalogs_result() throw();
   TGetCatalogsResp success;
 
   _TCLIService_GetCatalogs_result__isset __isset;
 
-  void __set_success(const TGetCatalogsResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetCatalogsResp& val);
 
   bool operator == (const TCLIService_GetCatalogs_result & rhs) const
   {
@@ -749,47 +817,53 @@ class TCLIService_GetCatalogs_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetCatalogs_result& obj);
 };
 
 typedef struct _TCLIService_GetCatalogs_presult__isset {
   _TCLIService_GetCatalogs_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetCatalogs_presult__isset;
 
 class TCLIService_GetCatalogs_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_GetCatalogs_presult() throw() {}
 
+  virtual ~TCLIService_GetCatalogs_presult() throw();
   TGetCatalogsResp* success;
 
   _TCLIService_GetCatalogs_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetCatalogs_presult& obj);
 };
 
 typedef struct _TCLIService_GetSchemas_args__isset {
   _TCLIService_GetSchemas_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetSchemas_args__isset;
 
 class TCLIService_GetSchemas_args {
  public:
 
+  static const char* ascii_fingerprint; // = "34B9FACB4B4C34ABAEDCF0A2B60345DE";
+  static const uint8_t binary_fingerprint[16]; // = {0x34,0xB9,0xFA,0xCB,0x4B,0x4C,0x34,0xAB,0xAE,0xDC,0xF0,0xA2,0xB6,0x03,0x45,0xDE};
+
+  TCLIService_GetSchemas_args(const TCLIService_GetSchemas_args&);
+  TCLIService_GetSchemas_args& operator=(const TCLIService_GetSchemas_args&);
   TCLIService_GetSchemas_args() {
   }
 
-  virtual ~TCLIService_GetSchemas_args() throw() {}
-
+  virtual ~TCLIService_GetSchemas_args() throw();
   TGetSchemasReq req;
 
   _TCLIService_GetSchemas_args__isset __isset;
 
-  void __set_req(const TGetSchemasReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetSchemasReq& val);
 
   bool operator == (const TCLIService_GetSchemas_args & rhs) const
   {
@@ -806,41 +880,47 @@ class TCLIService_GetSchemas_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetSchemas_args& obj);
 };
 
 
 class TCLIService_GetSchemas_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "34B9FACB4B4C34ABAEDCF0A2B60345DE";
+  static const uint8_t binary_fingerprint[16]; // = {0x34,0xB9,0xFA,0xCB,0x4B,0x4C,0x34,0xAB,0xAE,0xDC,0xF0,0xA2,0xB6,0x03,0x45,0xDE};
 
-  virtual ~TCLIService_GetSchemas_pargs() throw() {}
 
+  virtual ~TCLIService_GetSchemas_pargs() throw();
   const TGetSchemasReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetSchemas_pargs& obj);
 };
 
 typedef struct _TCLIService_GetSchemas_result__isset {
   _TCLIService_GetSchemas_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetSchemas_result__isset;
 
 class TCLIService_GetSchemas_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_GetSchemas_result(const TCLIService_GetSchemas_result&);
+  TCLIService_GetSchemas_result& operator=(const TCLIService_GetSchemas_result&);
   TCLIService_GetSchemas_result() {
   }
 
-  virtual ~TCLIService_GetSchemas_result() throw() {}
-
+  virtual ~TCLIService_GetSchemas_result() throw();
   TGetSchemasResp success;
 
   _TCLIService_GetSchemas_result__isset __isset;
 
-  void __set_success(const TGetSchemasResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetSchemasResp& val);
 
   bool operator == (const TCLIService_GetSchemas_result & rhs) const
   {
@@ -857,47 +937,53 @@ class TCLIService_GetSchemas_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetSchemas_result& obj);
 };
 
 typedef struct _TCLIService_GetSchemas_presult__isset {
   _TCLIService_GetSchemas_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetSchemas_presult__isset;
 
 class TCLIService_GetSchemas_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_GetSchemas_presult() throw() {}
 
+  virtual ~TCLIService_GetSchemas_presult() throw();
   TGetSchemasResp* success;
 
   _TCLIService_GetSchemas_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetSchemas_presult& obj);
 };
 
 typedef struct _TCLIService_GetTables_args__isset {
   _TCLIService_GetTables_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetTables_args__isset;
 
 class TCLIService_GetTables_args {
  public:
 
+  static const char* ascii_fingerprint; // = "58075D8350502C9B1F3532079C1CF7A6";
+  static const uint8_t binary_fingerprint[16]; // = {0x58,0x07,0x5D,0x83,0x50,0x50,0x2C,0x9B,0x1F,0x35,0x32,0x07,0x9C,0x1C,0xF7,0xA6};
+
+  TCLIService_GetTables_args(const TCLIService_GetTables_args&);
+  TCLIService_GetTables_args& operator=(const TCLIService_GetTables_args&);
   TCLIService_GetTables_args() {
   }
 
-  virtual ~TCLIService_GetTables_args() throw() {}
-
+  virtual ~TCLIService_GetTables_args() throw();
   TGetTablesReq req;
 
   _TCLIService_GetTables_args__isset __isset;
 
-  void __set_req(const TGetTablesReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetTablesReq& val);
 
   bool operator == (const TCLIService_GetTables_args & rhs) const
   {
@@ -914,41 +1000,47 @@ class TCLIService_GetTables_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTables_args& obj);
 };
 
 
 class TCLIService_GetTables_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "58075D8350502C9B1F3532079C1CF7A6";
+  static const uint8_t binary_fingerprint[16]; // = {0x58,0x07,0x5D,0x83,0x50,0x50,0x2C,0x9B,0x1F,0x35,0x32,0x07,0x9C,0x1C,0xF7,0xA6};
 
-  virtual ~TCLIService_GetTables_pargs() throw() {}
 
+  virtual ~TCLIService_GetTables_pargs() throw();
   const TGetTablesReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTables_pargs& obj);
 };
 
 typedef struct _TCLIService_GetTables_result__isset {
   _TCLIService_GetTables_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetTables_result__isset;
 
 class TCLIService_GetTables_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_GetTables_result(const TCLIService_GetTables_result&);
+  TCLIService_GetTables_result& operator=(const TCLIService_GetTables_result&);
   TCLIService_GetTables_result() {
   }
 
-  virtual ~TCLIService_GetTables_result() throw() {}
-
+  virtual ~TCLIService_GetTables_result() throw();
   TGetTablesResp success;
 
   _TCLIService_GetTables_result__isset __isset;
 
-  void __set_success(const TGetTablesResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetTablesResp& val);
 
   bool operator == (const TCLIService_GetTables_result & rhs) const
   {
@@ -965,47 +1057,53 @@ class TCLIService_GetTables_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTables_result& obj);
 };
 
 typedef struct _TCLIService_GetTables_presult__isset {
   _TCLIService_GetTables_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetTables_presult__isset;
 
 class TCLIService_GetTables_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_GetTables_presult() throw() {}
 
+  virtual ~TCLIService_GetTables_presult() throw();
   TGetTablesResp* success;
 
   _TCLIService_GetTables_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTables_presult& obj);
 };
 
 typedef struct _TCLIService_GetTableTypes_args__isset {
   _TCLIService_GetTableTypes_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetTableTypes_args__isset;
 
 class TCLIService_GetTableTypes_args {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
+
+  TCLIService_GetTableTypes_args(const TCLIService_GetTableTypes_args&);
+  TCLIService_GetTableTypes_args& operator=(const TCLIService_GetTableTypes_args&);
   TCLIService_GetTableTypes_args() {
   }
 
-  virtual ~TCLIService_GetTableTypes_args() throw() {}
-
+  virtual ~TCLIService_GetTableTypes_args() throw();
   TGetTableTypesReq req;
 
   _TCLIService_GetTableTypes_args__isset __isset;
 
-  void __set_req(const TGetTableTypesReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetTableTypesReq& val);
 
   bool operator == (const TCLIService_GetTableTypes_args & rhs) const
   {
@@ -1022,41 +1120,47 @@ class TCLIService_GetTableTypes_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTableTypes_args& obj);
 };
 
 
 class TCLIService_GetTableTypes_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "FD7076C37D193E2A343D9691B59D94EC";
+  static const uint8_t binary_fingerprint[16]; // = {0xFD,0x70,0x76,0xC3,0x7D,0x19,0x3E,0x2A,0x34,0x3D,0x96,0x91,0xB5,0x9D,0x94,0xEC};
 
-  virtual ~TCLIService_GetTableTypes_pargs() throw() {}
 
+  virtual ~TCLIService_GetTableTypes_pargs() throw();
   const TGetTableTypesReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTableTypes_pargs& obj);
 };
 
 typedef struct _TCLIService_GetTableTypes_result__isset {
   _TCLIService_GetTableTypes_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetTableTypes_result__isset;
 
 class TCLIService_GetTableTypes_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_GetTableTypes_result(const TCLIService_GetTableTypes_result&);
+  TCLIService_GetTableTypes_result& operator=(const TCLIService_GetTableTypes_result&);
   TCLIService_GetTableTypes_result() {
   }
 
-  virtual ~TCLIService_GetTableTypes_result() throw() {}
-
+  virtual ~TCLIService_GetTableTypes_result() throw();
   TGetTableTypesResp success;
 
   _TCLIService_GetTableTypes_result__isset __isset;
 
-  void __set_success(const TGetTableTypesResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetTableTypesResp& val);
 
   bool operator == (const TCLIService_GetTableTypes_result & rhs) const
   {
@@ -1073,47 +1177,53 @@ class TCLIService_GetTableTypes_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTableTypes_result& obj);
 };
 
 typedef struct _TCLIService_GetTableTypes_presult__isset {
   _TCLIService_GetTableTypes_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetTableTypes_presult__isset;
 
 class TCLIService_GetTableTypes_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_GetTableTypes_presult() throw() {}
 
+  virtual ~TCLIService_GetTableTypes_presult() throw();
   TGetTableTypesResp* success;
 
   _TCLIService_GetTableTypes_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetTableTypes_presult& obj);
 };
 
 typedef struct _TCLIService_GetColumns_args__isset {
   _TCLIService_GetColumns_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetColumns_args__isset;
 
 class TCLIService_GetColumns_args {
  public:
 
+  static const char* ascii_fingerprint; // = "7894A0356591B039C72040E21BAAC3E3";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x94,0xA0,0x35,0x65,0x91,0xB0,0x39,0xC7,0x20,0x40,0xE2,0x1B,0xAA,0xC3,0xE3};
+
+  TCLIService_GetColumns_args(const TCLIService_GetColumns_args&);
+  TCLIService_GetColumns_args& operator=(const TCLIService_GetColumns_args&);
   TCLIService_GetColumns_args() {
   }
 
-  virtual ~TCLIService_GetColumns_args() throw() {}
-
+  virtual ~TCLIService_GetColumns_args() throw();
   TGetColumnsReq req;
 
   _TCLIService_GetColumns_args__isset __isset;
 
-  void __set_req(const TGetColumnsReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetColumnsReq& val);
 
   bool operator == (const TCLIService_GetColumns_args & rhs) const
   {
@@ -1130,41 +1240,47 @@ class TCLIService_GetColumns_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetColumns_args& obj);
 };
 
 
 class TCLIService_GetColumns_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "7894A0356591B039C72040E21BAAC3E3";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x94,0xA0,0x35,0x65,0x91,0xB0,0x39,0xC7,0x20,0x40,0xE2,0x1B,0xAA,0xC3,0xE3};
 
-  virtual ~TCLIService_GetColumns_pargs() throw() {}
 
+  virtual ~TCLIService_GetColumns_pargs() throw();
   const TGetColumnsReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetColumns_pargs& obj);
 };
 
 typedef struct _TCLIService_GetColumns_result__isset {
   _TCLIService_GetColumns_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetColumns_result__isset;
 
 class TCLIService_GetColumns_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_GetColumns_result(const TCLIService_GetColumns_result&);
+  TCLIService_GetColumns_result& operator=(const TCLIService_GetColumns_result&);
   TCLIService_GetColumns_result() {
   }
 
-  virtual ~TCLIService_GetColumns_result() throw() {}
-
+  virtual ~TCLIService_GetColumns_result() throw();
   TGetColumnsResp success;
 
   _TCLIService_GetColumns_result__isset __isset;
 
-  void __set_success(const TGetColumnsResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetColumnsResp& val);
 
   bool operator == (const TCLIService_GetColumns_result & rhs) const
   {
@@ -1181,47 +1297,53 @@ class TCLIService_GetColumns_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetColumns_result& obj);
 };
 
 typedef struct _TCLIService_GetColumns_presult__isset {
   _TCLIService_GetColumns_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetColumns_presult__isset;
 
 class TCLIService_GetColumns_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_GetColumns_presult() throw() {}
 
+  virtual ~TCLIService_GetColumns_presult() throw();
   TGetColumnsResp* success;
 
   _TCLIService_GetColumns_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetColumns_presult& obj);
 };
 
 typedef struct _TCLIService_GetFunctions_args__isset {
   _TCLIService_GetFunctions_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetFunctions_args__isset;
 
 class TCLIService_GetFunctions_args {
  public:
 
+  static const char* ascii_fingerprint; // = "AC28BA383D0EC96F55B7C42FA3E1AF52";
+  static const uint8_t binary_fingerprint[16]; // = {0xAC,0x28,0xBA,0x38,0x3D,0x0E,0xC9,0x6F,0x55,0xB7,0xC4,0x2F,0xA3,0xE1,0xAF,0x52};
+
+  TCLIService_GetFunctions_args(const TCLIService_GetFunctions_args&);
+  TCLIService_GetFunctions_args& operator=(const TCLIService_GetFunctions_args&);
   TCLIService_GetFunctions_args() {
   }
 
-  virtual ~TCLIService_GetFunctions_args() throw() {}
-
+  virtual ~TCLIService_GetFunctions_args() throw();
   TGetFunctionsReq req;
 
   _TCLIService_GetFunctions_args__isset __isset;
 
-  void __set_req(const TGetFunctionsReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetFunctionsReq& val);
 
   bool operator == (const TCLIService_GetFunctions_args & rhs) const
   {
@@ -1238,41 +1360,47 @@ class TCLIService_GetFunctions_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetFunctions_args& obj);
 };
 
 
 class TCLIService_GetFunctions_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "AC28BA383D0EC96F55B7C42FA3E1AF52";
+  static const uint8_t binary_fingerprint[16]; // = {0xAC,0x28,0xBA,0x38,0x3D,0x0E,0xC9,0x6F,0x55,0xB7,0xC4,0x2F,0xA3,0xE1,0xAF,0x52};
 
-  virtual ~TCLIService_GetFunctions_pargs() throw() {}
 
+  virtual ~TCLIService_GetFunctions_pargs() throw();
   const TGetFunctionsReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetFunctions_pargs& obj);
 };
 
 typedef struct _TCLIService_GetFunctions_result__isset {
   _TCLIService_GetFunctions_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetFunctions_result__isset;
 
 class TCLIService_GetFunctions_result {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
+
+  TCLIService_GetFunctions_result(const TCLIService_GetFunctions_result&);
+  TCLIService_GetFunctions_result& operator=(const TCLIService_GetFunctions_result&);
   TCLIService_GetFunctions_result() {
   }
 
-  virtual ~TCLIService_GetFunctions_result() throw() {}
-
+  virtual ~TCLIService_GetFunctions_result() throw();
   TGetFunctionsResp success;
 
   _TCLIService_GetFunctions_result__isset __isset;
 
-  void __set_success(const TGetFunctionsResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetFunctionsResp& val);
 
   bool operator == (const TCLIService_GetFunctions_result & rhs) const
   {
@@ -1289,47 +1417,53 @@ class TCLIService_GetFunctions_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetFunctions_result& obj);
 };
 
 typedef struct _TCLIService_GetFunctions_presult__isset {
   _TCLIService_GetFunctions_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetFunctions_presult__isset;
 
 class TCLIService_GetFunctions_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "783BF5EE3B1FEAC8DF5FDAEF1F551CDF";
+  static const uint8_t binary_fingerprint[16]; // = {0x78,0x3B,0xF5,0xEE,0x3B,0x1F,0xEA,0xC8,0xDF,0x5F,0xDA,0xEF,0x1F,0x55,0x1C,0xDF};
 
-  virtual ~TCLIService_GetFunctions_presult() throw() {}
 
+  virtual ~TCLIService_GetFunctions_presult() throw();
   TGetFunctionsResp* success;
 
   _TCLIService_GetFunctions_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetFunctions_presult& obj);
 };
 
 typedef struct _TCLIService_GetOperationStatus_args__isset {
   _TCLIService_GetOperationStatus_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetOperationStatus_args__isset;
 
 class TCLIService_GetOperationStatus_args {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
+
+  TCLIService_GetOperationStatus_args(const TCLIService_GetOperationStatus_args&);
+  TCLIService_GetOperationStatus_args& operator=(const TCLIService_GetOperationStatus_args&);
   TCLIService_GetOperationStatus_args() {
   }
 
-  virtual ~TCLIService_GetOperationStatus_args() throw() {}
-
+  virtual ~TCLIService_GetOperationStatus_args() throw();
   TGetOperationStatusReq req;
 
   _TCLIService_GetOperationStatus_args__isset __isset;
 
-  void __set_req(const TGetOperationStatusReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetOperationStatusReq& val);
 
   bool operator == (const TCLIService_GetOperationStatus_args & rhs) const
   {
@@ -1346,41 +1480,47 @@ class TCLIService_GetOperationStatus_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetOperationStatus_args& obj);
 };
 
 
 class TCLIService_GetOperationStatus_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
 
-  virtual ~TCLIService_GetOperationStatus_pargs() throw() {}
 
+  virtual ~TCLIService_GetOperationStatus_pargs() throw();
   const TGetOperationStatusReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetOperationStatus_pargs& obj);
 };
 
 typedef struct _TCLIService_GetOperationStatus_result__isset {
   _TCLIService_GetOperationStatus_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetOperationStatus_result__isset;
 
 class TCLIService_GetOperationStatus_result {
  public:
 
+  static const char* ascii_fingerprint; // = "C399947D185D259358E6B922C40ACF85";
+  static const uint8_t binary_fingerprint[16]; // = {0xC3,0x99,0x94,0x7D,0x18,0x5D,0x25,0x93,0x58,0xE6,0xB9,0x22,0xC4,0x0A,0xCF,0x85};
+
+  TCLIService_GetOperationStatus_result(const TCLIService_GetOperationStatus_result&);
+  TCLIService_GetOperationStatus_result& operator=(const TCLIService_GetOperationStatus_result&);
   TCLIService_GetOperationStatus_result() {
   }
 
-  virtual ~TCLIService_GetOperationStatus_result() throw() {}
-
+  virtual ~TCLIService_GetOperationStatus_result() throw();
   TGetOperationStatusResp success;
 
   _TCLIService_GetOperationStatus_result__isset __isset;
 
-  void __set_success(const TGetOperationStatusResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetOperationStatusResp& val);
 
   bool operator == (const TCLIService_GetOperationStatus_result & rhs) const
   {
@@ -1397,47 +1537,53 @@ class TCLIService_GetOperationStatus_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetOperationStatus_result& obj);
 };
 
 typedef struct _TCLIService_GetOperationStatus_presult__isset {
   _TCLIService_GetOperationStatus_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetOperationStatus_presult__isset;
 
 class TCLIService_GetOperationStatus_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "C399947D185D259358E6B922C40ACF85";
+  static const uint8_t binary_fingerprint[16]; // = {0xC3,0x99,0x94,0x7D,0x18,0x5D,0x25,0x93,0x58,0xE6,0xB9,0x22,0xC4,0x0A,0xCF,0x85};
 
-  virtual ~TCLIService_GetOperationStatus_presult() throw() {}
 
+  virtual ~TCLIService_GetOperationStatus_presult() throw();
   TGetOperationStatusResp* success;
 
   _TCLIService_GetOperationStatus_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetOperationStatus_presult& obj);
 };
 
 typedef struct _TCLIService_CancelOperation_args__isset {
   _TCLIService_CancelOperation_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_CancelOperation_args__isset;
 
 class TCLIService_CancelOperation_args {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
+
+  TCLIService_CancelOperation_args(const TCLIService_CancelOperation_args&);
+  TCLIService_CancelOperation_args& operator=(const TCLIService_CancelOperation_args&);
   TCLIService_CancelOperation_args() {
   }
 
-  virtual ~TCLIService_CancelOperation_args() throw() {}
-
+  virtual ~TCLIService_CancelOperation_args() throw();
   TCancelOperationReq req;
 
   _TCLIService_CancelOperation_args__isset __isset;
 
-  void __set_req(const TCancelOperationReq& val) {
-    req = val;
-  }
+  void __set_req(const TCancelOperationReq& val);
 
   bool operator == (const TCLIService_CancelOperation_args & rhs) const
   {
@@ -1454,41 +1600,47 @@ class TCLIService_CancelOperation_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelOperation_args& obj);
 };
 
 
 class TCLIService_CancelOperation_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
 
-  virtual ~TCLIService_CancelOperation_pargs() throw() {}
 
+  virtual ~TCLIService_CancelOperation_pargs() throw();
   const TCancelOperationReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelOperation_pargs& obj);
 };
 
 typedef struct _TCLIService_CancelOperation_result__isset {
   _TCLIService_CancelOperation_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CancelOperation_result__isset;
 
 class TCLIService_CancelOperation_result {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
+
+  TCLIService_CancelOperation_result(const TCLIService_CancelOperation_result&);
+  TCLIService_CancelOperation_result& operator=(const TCLIService_CancelOperation_result&);
   TCLIService_CancelOperation_result() {
   }
 
-  virtual ~TCLIService_CancelOperation_result() throw() {}
-
+  virtual ~TCLIService_CancelOperation_result() throw();
   TCancelOperationResp success;
 
   _TCLIService_CancelOperation_result__isset __isset;
 
-  void __set_success(const TCancelOperationResp& val) {
-    success = val;
-  }
+  void __set_success(const TCancelOperationResp& val);
 
   bool operator == (const TCLIService_CancelOperation_result & rhs) const
   {
@@ -1505,47 +1657,53 @@ class TCLIService_CancelOperation_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelOperation_result& obj);
 };
 
 typedef struct _TCLIService_CancelOperation_presult__isset {
   _TCLIService_CancelOperation_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CancelOperation_presult__isset;
 
 class TCLIService_CancelOperation_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
 
-  virtual ~TCLIService_CancelOperation_presult() throw() {}
 
+  virtual ~TCLIService_CancelOperation_presult() throw();
   TCancelOperationResp* success;
 
   _TCLIService_CancelOperation_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelOperation_presult& obj);
 };
 
 typedef struct _TCLIService_CloseOperation_args__isset {
   _TCLIService_CloseOperation_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_CloseOperation_args__isset;
 
 class TCLIService_CloseOperation_args {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
+
+  TCLIService_CloseOperation_args(const TCLIService_CloseOperation_args&);
+  TCLIService_CloseOperation_args& operator=(const TCLIService_CloseOperation_args&);
   TCLIService_CloseOperation_args() {
   }
 
-  virtual ~TCLIService_CloseOperation_args() throw() {}
-
+  virtual ~TCLIService_CloseOperation_args() throw();
   TCloseOperationReq req;
 
   _TCLIService_CloseOperation_args__isset __isset;
 
-  void __set_req(const TCloseOperationReq& val) {
-    req = val;
-  }
+  void __set_req(const TCloseOperationReq& val);
 
   bool operator == (const TCLIService_CloseOperation_args & rhs) const
   {
@@ -1562,41 +1720,47 @@ class TCLIService_CloseOperation_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseOperation_args& obj);
 };
 
 
 class TCLIService_CloseOperation_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
 
-  virtual ~TCLIService_CloseOperation_pargs() throw() {}
 
+  virtual ~TCLIService_CloseOperation_pargs() throw();
   const TCloseOperationReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseOperation_pargs& obj);
 };
 
 typedef struct _TCLIService_CloseOperation_result__isset {
   _TCLIService_CloseOperation_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CloseOperation_result__isset;
 
 class TCLIService_CloseOperation_result {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
+
+  TCLIService_CloseOperation_result(const TCLIService_CloseOperation_result&);
+  TCLIService_CloseOperation_result& operator=(const TCLIService_CloseOperation_result&);
   TCLIService_CloseOperation_result() {
   }
 
-  virtual ~TCLIService_CloseOperation_result() throw() {}
-
+  virtual ~TCLIService_CloseOperation_result() throw();
   TCloseOperationResp success;
 
   _TCLIService_CloseOperation_result__isset __isset;
 
-  void __set_success(const TCloseOperationResp& val) {
-    success = val;
-  }
+  void __set_success(const TCloseOperationResp& val);
 
   bool operator == (const TCLIService_CloseOperation_result & rhs) const
   {
@@ -1613,47 +1777,53 @@ class TCLIService_CloseOperation_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseOperation_result& obj);
 };
 
 typedef struct _TCLIService_CloseOperation_presult__isset {
   _TCLIService_CloseOperation_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CloseOperation_presult__isset;
 
 class TCLIService_CloseOperation_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
 
-  virtual ~TCLIService_CloseOperation_presult() throw() {}
 
+  virtual ~TCLIService_CloseOperation_presult() throw();
   TCloseOperationResp* success;
 
   _TCLIService_CloseOperation_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CloseOperation_presult& obj);
 };
 
 typedef struct _TCLIService_GetResultSetMetadata_args__isset {
   _TCLIService_GetResultSetMetadata_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetResultSetMetadata_args__isset;
 
 class TCLIService_GetResultSetMetadata_args {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
+
+  TCLIService_GetResultSetMetadata_args(const TCLIService_GetResultSetMetadata_args&);
+  TCLIService_GetResultSetMetadata_args& operator=(const TCLIService_GetResultSetMetadata_args&);
   TCLIService_GetResultSetMetadata_args() {
   }
 
-  virtual ~TCLIService_GetResultSetMetadata_args() throw() {}
-
+  virtual ~TCLIService_GetResultSetMetadata_args() throw();
   TGetResultSetMetadataReq req;
 
   _TCLIService_GetResultSetMetadata_args__isset __isset;
 
-  void __set_req(const TGetResultSetMetadataReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetResultSetMetadataReq& val);
 
   bool operator == (const TCLIService_GetResultSetMetadata_args & rhs) const
   {
@@ -1670,41 +1840,47 @@ class TCLIService_GetResultSetMetadata_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetResultSetMetadata_args& obj);
 };
 
 
 class TCLIService_GetResultSetMetadata_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "2A0009415DC2A8A9CDCF3A75C16ADBE7";
+  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x00,0x09,0x41,0x5D,0xC2,0xA8,0xA9,0xCD,0xCF,0x3A,0x75,0xC1,0x6A,0xDB,0xE7};
 
-  virtual ~TCLIService_GetResultSetMetadata_pargs() throw() {}
 
+  virtual ~TCLIService_GetResultSetMetadata_pargs() throw();
   const TGetResultSetMetadataReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetResultSetMetadata_pargs& obj);
 };
 
 typedef struct _TCLIService_GetResultSetMetadata_result__isset {
   _TCLIService_GetResultSetMetadata_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetResultSetMetadata_result__isset;
 
 class TCLIService_GetResultSetMetadata_result {
  public:
 
+  static const char* ascii_fingerprint; // = "748CA3BE2055D5C1AD7EAAEF01F7C463";
+  static const uint8_t binary_fingerprint[16]; // = {0x74,0x8C,0xA3,0xBE,0x20,0x55,0xD5,0xC1,0xAD,0x7E,0xAA,0xEF,0x01,0xF7,0xC4,0x63};
+
+  TCLIService_GetResultSetMetadata_result(const TCLIService_GetResultSetMetadata_result&);
+  TCLIService_GetResultSetMetadata_result& operator=(const TCLIService_GetResultSetMetadata_result&);
   TCLIService_GetResultSetMetadata_result() {
   }
 
-  virtual ~TCLIService_GetResultSetMetadata_result() throw() {}
-
+  virtual ~TCLIService_GetResultSetMetadata_result() throw();
   TGetResultSetMetadataResp success;
 
   _TCLIService_GetResultSetMetadata_result__isset __isset;
 
-  void __set_success(const TGetResultSetMetadataResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetResultSetMetadataResp& val);
 
   bool operator == (const TCLIService_GetResultSetMetadata_result & rhs) const
   {
@@ -1721,47 +1897,53 @@ class TCLIService_GetResultSetMetadata_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetResultSetMetadata_result& obj);
 };
 
 typedef struct _TCLIService_GetResultSetMetadata_presult__isset {
   _TCLIService_GetResultSetMetadata_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetResultSetMetadata_presult__isset;
 
 class TCLIService_GetResultSetMetadata_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "748CA3BE2055D5C1AD7EAAEF01F7C463";
+  static const uint8_t binary_fingerprint[16]; // = {0x74,0x8C,0xA3,0xBE,0x20,0x55,0xD5,0xC1,0xAD,0x7E,0xAA,0xEF,0x01,0xF7,0xC4,0x63};
 
-  virtual ~TCLIService_GetResultSetMetadata_presult() throw() {}
 
+  virtual ~TCLIService_GetResultSetMetadata_presult() throw();
   TGetResultSetMetadataResp* success;
 
   _TCLIService_GetResultSetMetadata_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetResultSetMetadata_presult& obj);
 };
 
 typedef struct _TCLIService_FetchResults_args__isset {
   _TCLIService_FetchResults_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_FetchResults_args__isset;
 
 class TCLIService_FetchResults_args {
  public:
 
+  static const char* ascii_fingerprint; // = "9861C5443566158A1DAEAC80886635C8";
+  static const uint8_t binary_fingerprint[16]; // = {0x98,0x61,0xC5,0x44,0x35,0x66,0x15,0x8A,0x1D,0xAE,0xAC,0x80,0x88,0x66,0x35,0xC8};
+
+  TCLIService_FetchResults_args(const TCLIService_FetchResults_args&);
+  TCLIService_FetchResults_args& operator=(const TCLIService_FetchResults_args&);
   TCLIService_FetchResults_args() {
   }
 
-  virtual ~TCLIService_FetchResults_args() throw() {}
-
+  virtual ~TCLIService_FetchResults_args() throw();
   TFetchResultsReq req;
 
   _TCLIService_FetchResults_args__isset __isset;
 
-  void __set_req(const TFetchResultsReq& val) {
-    req = val;
-  }
+  void __set_req(const TFetchResultsReq& val);
 
   bool operator == (const TCLIService_FetchResults_args & rhs) const
   {
@@ -1778,41 +1960,47 @@ class TCLIService_FetchResults_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_FetchResults_args& obj);
 };
 
 
 class TCLIService_FetchResults_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "9861C5443566158A1DAEAC80886635C8";
+  static const uint8_t binary_fingerprint[16]; // = {0x98,0x61,0xC5,0x44,0x35,0x66,0x15,0x8A,0x1D,0xAE,0xAC,0x80,0x88,0x66,0x35,0xC8};
 
-  virtual ~TCLIService_FetchResults_pargs() throw() {}
 
+  virtual ~TCLIService_FetchResults_pargs() throw();
   const TFetchResultsReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_FetchResults_pargs& obj);
 };
 
 typedef struct _TCLIService_FetchResults_result__isset {
   _TCLIService_FetchResults_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_FetchResults_result__isset;
 
 class TCLIService_FetchResults_result {
  public:
 
+  static const char* ascii_fingerprint; // = "CDEF797B9FFCA6B2CD18163A3D78F196";
+  static const uint8_t binary_fingerprint[16]; // = {0xCD,0xEF,0x79,0x7B,0x9F,0xFC,0xA6,0xB2,0xCD,0x18,0x16,0x3A,0x3D,0x78,0xF1,0x96};
+
+  TCLIService_FetchResults_result(const TCLIService_FetchResults_result&);
+  TCLIService_FetchResults_result& operator=(const TCLIService_FetchResults_result&);
   TCLIService_FetchResults_result() {
   }
 
-  virtual ~TCLIService_FetchResults_result() throw() {}
-
+  virtual ~TCLIService_FetchResults_result() throw();
   TFetchResultsResp success;
 
   _TCLIService_FetchResults_result__isset __isset;
 
-  void __set_success(const TFetchResultsResp& val) {
-    success = val;
-  }
+  void __set_success(const TFetchResultsResp& val);
 
   bool operator == (const TCLIService_FetchResults_result & rhs) const
   {
@@ -1829,47 +2017,53 @@ class TCLIService_FetchResults_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_FetchResults_result& obj);
 };
 
 typedef struct _TCLIService_FetchResults_presult__isset {
   _TCLIService_FetchResults_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_FetchResults_presult__isset;
 
 class TCLIService_FetchResults_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "CDEF797B9FFCA6B2CD18163A3D78F196";
+  static const uint8_t binary_fingerprint[16]; // = {0xCD,0xEF,0x79,0x7B,0x9F,0xFC,0xA6,0xB2,0xCD,0x18,0x16,0x3A,0x3D,0x78,0xF1,0x96};
 
-  virtual ~TCLIService_FetchResults_presult() throw() {}
 
+  virtual ~TCLIService_FetchResults_presult() throw();
   TFetchResultsResp* success;
 
   _TCLIService_FetchResults_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_FetchResults_presult& obj);
 };
 
 typedef struct _TCLIService_GetDelegationToken_args__isset {
   _TCLIService_GetDelegationToken_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_GetDelegationToken_args__isset;
 
 class TCLIService_GetDelegationToken_args {
  public:
 
+  static const char* ascii_fingerprint; // = "BF8EEEB8C67FB6195D3D9BA5BA2C58A4";
+  static const uint8_t binary_fingerprint[16]; // = {0xBF,0x8E,0xEE,0xB8,0xC6,0x7F,0xB6,0x19,0x5D,0x3D,0x9B,0xA5,0xBA,0x2C,0x58,0xA4};
+
+  TCLIService_GetDelegationToken_args(const TCLIService_GetDelegationToken_args&);
+  TCLIService_GetDelegationToken_args& operator=(const TCLIService_GetDelegationToken_args&);
   TCLIService_GetDelegationToken_args() {
   }
 
-  virtual ~TCLIService_GetDelegationToken_args() throw() {}
-
+  virtual ~TCLIService_GetDelegationToken_args() throw();
   TGetDelegationTokenReq req;
 
   _TCLIService_GetDelegationToken_args__isset __isset;
 
-  void __set_req(const TGetDelegationTokenReq& val) {
-    req = val;
-  }
+  void __set_req(const TGetDelegationTokenReq& val);
 
   bool operator == (const TCLIService_GetDelegationToken_args & rhs) const
   {
@@ -1886,41 +2080,47 @@ class TCLIService_GetDelegationToken_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetDelegationToken_args& obj);
 };
 
 
 class TCLIService_GetDelegationToken_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "BF8EEEB8C67FB6195D3D9BA5BA2C58A4";
+  static const uint8_t binary_fingerprint[16]; // = {0xBF,0x8E,0xEE,0xB8,0xC6,0x7F,0xB6,0x19,0x5D,0x3D,0x9B,0xA5,0xBA,0x2C,0x58,0xA4};
 
-  virtual ~TCLIService_GetDelegationToken_pargs() throw() {}
 
+  virtual ~TCLIService_GetDelegationToken_pargs() throw();
   const TGetDelegationTokenReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetDelegationToken_pargs& obj);
 };
 
 typedef struct _TCLIService_GetDelegationToken_result__isset {
   _TCLIService_GetDelegationToken_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetDelegationToken_result__isset;
 
 class TCLIService_GetDelegationToken_result {
  public:
 
+  static const char* ascii_fingerprint; // = "58C1B84BE91071117FFEBB0AFA1636F7";
+  static const uint8_t binary_fingerprint[16]; // = {0x58,0xC1,0xB8,0x4B,0xE9,0x10,0x71,0x11,0x7F,0xFE,0xBB,0x0A,0xFA,0x16,0x36,0xF7};
+
+  TCLIService_GetDelegationToken_result(const TCLIService_GetDelegationToken_result&);
+  TCLIService_GetDelegationToken_result& operator=(const TCLIService_GetDelegationToken_result&);
   TCLIService_GetDelegationToken_result() {
   }
 
-  virtual ~TCLIService_GetDelegationToken_result() throw() {}
-
+  virtual ~TCLIService_GetDelegationToken_result() throw();
   TGetDelegationTokenResp success;
 
   _TCLIService_GetDelegationToken_result__isset __isset;
 
-  void __set_success(const TGetDelegationTokenResp& val) {
-    success = val;
-  }
+  void __set_success(const TGetDelegationTokenResp& val);
 
   bool operator == (const TCLIService_GetDelegationToken_result & rhs) const
   {
@@ -1937,47 +2137,53 @@ class TCLIService_GetDelegationToken_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetDelegationToken_result& obj);
 };
 
 typedef struct _TCLIService_GetDelegationToken_presult__isset {
   _TCLIService_GetDelegationToken_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_GetDelegationToken_presult__isset;
 
 class TCLIService_GetDelegationToken_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "58C1B84BE91071117FFEBB0AFA1636F7";
+  static const uint8_t binary_fingerprint[16]; // = {0x58,0xC1,0xB8,0x4B,0xE9,0x10,0x71,0x11,0x7F,0xFE,0xBB,0x0A,0xFA,0x16,0x36,0xF7};
 
-  virtual ~TCLIService_GetDelegationToken_presult() throw() {}
 
+  virtual ~TCLIService_GetDelegationToken_presult() throw();
   TGetDelegationTokenResp* success;
 
   _TCLIService_GetDelegationToken_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_GetDelegationToken_presult& obj);
 };
 
 typedef struct _TCLIService_CancelDelegationToken_args__isset {
   _TCLIService_CancelDelegationToken_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_CancelDelegationToken_args__isset;
 
 class TCLIService_CancelDelegationToken_args {
  public:
 
+  static const char* ascii_fingerprint; // = "9C6A93D9444D84C6B888C2DA30E4CB54";
+  static const uint8_t binary_fingerprint[16]; // = {0x9C,0x6A,0x93,0xD9,0x44,0x4D,0x84,0xC6,0xB8,0x88,0xC2,0xDA,0x30,0xE4,0xCB,0x54};
+
+  TCLIService_CancelDelegationToken_args(const TCLIService_CancelDelegationToken_args&);
+  TCLIService_CancelDelegationToken_args& operator=(const TCLIService_CancelDelegationToken_args&);
   TCLIService_CancelDelegationToken_args() {
   }
 
-  virtual ~TCLIService_CancelDelegationToken_args() throw() {}
-
+  virtual ~TCLIService_CancelDelegationToken_args() throw();
   TCancelDelegationTokenReq req;
 
   _TCLIService_CancelDelegationToken_args__isset __isset;
 
-  void __set_req(const TCancelDelegationTokenReq& val) {
-    req = val;
-  }
+  void __set_req(const TCancelDelegationTokenReq& val);
 
   bool operator == (const TCLIService_CancelDelegationToken_args & rhs) const
   {
@@ -1994,41 +2200,47 @@ class TCLIService_CancelDelegationToken_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelDelegationToken_args& obj);
 };
 
 
 class TCLIService_CancelDelegationToken_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "9C6A93D9444D84C6B888C2DA30E4CB54";
+  static const uint8_t binary_fingerprint[16]; // = {0x9C,0x6A,0x93,0xD9,0x44,0x4D,0x84,0xC6,0xB8,0x88,0xC2,0xDA,0x30,0xE4,0xCB,0x54};
 
-  virtual ~TCLIService_CancelDelegationToken_pargs() throw() {}
 
+  virtual ~TCLIService_CancelDelegationToken_pargs() throw();
   const TCancelDelegationTokenReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelDelegationToken_pargs& obj);
 };
 
 typedef struct _TCLIService_CancelDelegationToken_result__isset {
   _TCLIService_CancelDelegationToken_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CancelDelegationToken_result__isset;
 
 class TCLIService_CancelDelegationToken_result {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
+
+  TCLIService_CancelDelegationToken_result(const TCLIService_CancelDelegationToken_result&);
+  TCLIService_CancelDelegationToken_result& operator=(const TCLIService_CancelDelegationToken_result&);
   TCLIService_CancelDelegationToken_result() {
   }
 
-  virtual ~TCLIService_CancelDelegationToken_result() throw() {}
-
+  virtual ~TCLIService_CancelDelegationToken_result() throw();
   TCancelDelegationTokenResp success;
 
   _TCLIService_CancelDelegationToken_result__isset __isset;
 
-  void __set_success(const TCancelDelegationTokenResp& val) {
-    success = val;
-  }
+  void __set_success(const TCancelDelegationTokenResp& val);
 
   bool operator == (const TCLIService_CancelDelegationToken_result & rhs) const
   {
@@ -2045,47 +2257,53 @@ class TCLIService_CancelDelegationToken_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelDelegationToken_result& obj);
 };
 
 typedef struct _TCLIService_CancelDelegationToken_presult__isset {
   _TCLIService_CancelDelegationToken_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_CancelDelegationToken_presult__isset;
 
 class TCLIService_CancelDelegationToken_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
 
-  virtual ~TCLIService_CancelDelegationToken_presult() throw() {}
 
+  virtual ~TCLIService_CancelDelegationToken_presult() throw();
   TCancelDelegationTokenResp* success;
 
   _TCLIService_CancelDelegationToken_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_CancelDelegationToken_presult& obj);
 };
 
 typedef struct _TCLIService_RenewDelegationToken_args__isset {
   _TCLIService_RenewDelegationToken_args__isset() : req(false) {}
-  bool req;
+  bool req :1;
 } _TCLIService_RenewDelegationToken_args__isset;
 
 class TCLIService_RenewDelegationToken_args {
  public:
 
+  static const char* ascii_fingerprint; // = "9C6A93D9444D84C6B888C2DA30E4CB54";
+  static const uint8_t binary_fingerprint[16]; // = {0x9C,0x6A,0x93,0xD9,0x44,0x4D,0x84,0xC6,0xB8,0x88,0xC2,0xDA,0x30,0xE4,0xCB,0x54};
+
+  TCLIService_RenewDelegationToken_args(const TCLIService_RenewDelegationToken_args&);
+  TCLIService_RenewDelegationToken_args& operator=(const TCLIService_RenewDelegationToken_args&);
   TCLIService_RenewDelegationToken_args() {
   }
 
-  virtual ~TCLIService_RenewDelegationToken_args() throw() {}
-
+  virtual ~TCLIService_RenewDelegationToken_args() throw();
   TRenewDelegationTokenReq req;
 
   _TCLIService_RenewDelegationToken_args__isset __isset;
 
-  void __set_req(const TRenewDelegationTokenReq& val) {
-    req = val;
-  }
+  void __set_req(const TRenewDelegationTokenReq& val);
 
   bool operator == (const TCLIService_RenewDelegationToken_args & rhs) const
   {
@@ -2102,41 +2320,47 @@ class TCLIService_RenewDelegationToken_args {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_RenewDelegationToken_args& obj);
 };
 
 
 class TCLIService_RenewDelegationToken_pargs {
  public:
 
+  static const char* ascii_fingerprint; // = "9C6A93D9444D84C6B888C2DA30E4CB54";
+  static const uint8_t binary_fingerprint[16]; // = {0x9C,0x6A,0x93,0xD9,0x44,0x4D,0x84,0xC6,0xB8,0x88,0xC2,0xDA,0x30,0xE4,0xCB,0x54};
 
-  virtual ~TCLIService_RenewDelegationToken_pargs() throw() {}
 
+  virtual ~TCLIService_RenewDelegationToken_pargs() throw();
   const TRenewDelegationTokenReq* req;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_RenewDelegationToken_pargs& obj);
 };
 
 typedef struct _TCLIService_RenewDelegationToken_result__isset {
   _TCLIService_RenewDelegationToken_result__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_RenewDelegationToken_result__isset;
 
 class TCLIService_RenewDelegationToken_result {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
+
+  TCLIService_RenewDelegationToken_result(const TCLIService_RenewDelegationToken_result&);
+  TCLIService_RenewDelegationToken_result& operator=(const TCLIService_RenewDelegationToken_result&);
   TCLIService_RenewDelegationToken_result() {
   }
 
-  virtual ~TCLIService_RenewDelegationToken_result() throw() {}
-
+  virtual ~TCLIService_RenewDelegationToken_result() throw();
   TRenewDelegationTokenResp success;
 
   _TCLIService_RenewDelegationToken_result__isset __isset;
 
-  void __set_success(const TRenewDelegationTokenResp& val) {
-    success = val;
-  }
+  void __set_success(const TRenewDelegationTokenResp& val);
 
   bool operator == (const TCLIService_RenewDelegationToken_result & rhs) const
   {
@@ -2153,41 +2377,50 @@ class TCLIService_RenewDelegationToken_result {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_RenewDelegationToken_result& obj);
 };
 
 typedef struct _TCLIService_RenewDelegationToken_presult__isset {
   _TCLIService_RenewDelegationToken_presult__isset() : success(false) {}
-  bool success;
+  bool success :1;
 } _TCLIService_RenewDelegationToken_presult__isset;
 
 class TCLIService_RenewDelegationToken_presult {
  public:
 
+  static const char* ascii_fingerprint; // = "BDB51A479DCD1EB1DB636FA1B4BE02A7";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0xB5,0x1A,0x47,0x9D,0xCD,0x1E,0xB1,0xDB,0x63,0x6F,0xA1,0xB4,0xBE,0x02,0xA7};
 
-  virtual ~TCLIService_RenewDelegationToken_presult() throw() {}
 
+  virtual ~TCLIService_RenewDelegationToken_presult() throw();
   TRenewDelegationTokenResp* success;
 
   _TCLIService_RenewDelegationToken_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
+  friend std::ostream& operator<<(std::ostream& out, const TCLIService_RenewDelegationToken_presult& obj);
 };
 
 class TCLIServiceClient : virtual public TCLIServiceIf {
  public:
-  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
-    piprot_(prot),
-    poprot_(prot) {
-    iprot_ = prot.get();
-    oprot_ = prot.get();
+  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
   }
-  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
-    piprot_(iprot),
-    poprot_(oprot) {
+ private:
+  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
     iprot_ = iprot.get();
     oprot_ = oprot.get();
   }
+ public:
   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
     return piprot_;
   }

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp
----------------------------------------------------------------------
diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp b/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp
index d1551b5..dcca5c8 100644
--- a/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp
+++ b/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/service/src/gen/thrift/gen-cpp/TCLIService_constants.h
----------------------------------------------------------------------
diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_constants.h b/service/src/gen/thrift/gen-cpp/TCLIService_constants.h
index e5a7a1f..8993394 100644
--- a/service/src/gen/thrift/gen-cpp/TCLIService_constants.h
+++ b/service/src/gen/thrift/gen-cpp/TCLIService_constants.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated


Mime
View raw message