http://git-wip-us.apache.org/repos/asf/hive/blob/2542f5cc/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h ---------------------------------------------------------------------- diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h new file mode 100644 index 0000000..d17edd3 --- /dev/null +++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h @@ -0,0 +1,2765 @@ +/** + * Autogenerated by Thrift Compiler (0.9.2) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef TCLIService_H +#define TCLIService_H + +#include <thrift/TDispatchProcessor.h> +#include "TCLIService_types.h" + +namespace apache { namespace hive { namespace service { namespace rpc { namespace thrift { + +class TCLIServiceIf { + public: + virtual ~TCLIServiceIf() {} + virtual void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req) = 0; + virtual void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req) = 0; + virtual void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req) = 0; + virtual void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req) = 0; + virtual void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req) = 0; + virtual void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req) = 0; + virtual void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req) = 0; + virtual void GetTables(TGetTablesResp& _return, const TGetTablesReq& req) = 0; + virtual void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req) = 0; + virtual void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req) = 0; + virtual void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req) = 0; + virtual void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req) = 0; + virtual void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req) = 0; + virtual void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req) = 0; + virtual void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req) = 0; + virtual void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req) = 0; + virtual void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) = 0; + virtual void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) = 0; + virtual void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) = 0; +}; + +class TCLIServiceIfFactory { + public: + typedef TCLIServiceIf Handler; + + virtual ~TCLIServiceIfFactory() {} + + virtual TCLIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(TCLIServiceIf* /* handler */) = 0; +}; + +class TCLIServiceIfSingletonFactory : virtual public TCLIServiceIfFactory { + public: + TCLIServiceIfSingletonFactory(const boost::shared_ptr<TCLIServiceIf>& iface) : iface_(iface) {} + virtual ~TCLIServiceIfSingletonFactory() {} + + virtual TCLIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(TCLIServiceIf* /* handler */) {} + + protected: + boost::shared_ptr<TCLIServiceIf> iface_; +}; + +class TCLIServiceNull : virtual public TCLIServiceIf { + public: + virtual ~TCLIServiceNull() {} + void OpenSession(TOpenSessionResp& /* _return */, const TOpenSessionReq& /* req */) { + return; + } + void CloseSession(TCloseSessionResp& /* _return */, const TCloseSessionReq& /* req */) { + return; + } + void GetInfo(TGetInfoResp& /* _return */, const TGetInfoReq& /* req */) { + return; + } + void ExecuteStatement(TExecuteStatementResp& /* _return */, const TExecuteStatementReq& /* req */) { + return; + } + void GetTypeInfo(TGetTypeInfoResp& /* _return */, const TGetTypeInfoReq& /* req */) { + return; + } + void GetCatalogs(TGetCatalogsResp& /* _return */, const TGetCatalogsReq& /* req */) { + return; + } + void GetSchemas(TGetSchemasResp& /* _return */, const TGetSchemasReq& /* req */) { + return; + } + void GetTables(TGetTablesResp& /* _return */, const TGetTablesReq& /* req */) { + return; + } + void GetTableTypes(TGetTableTypesResp& /* _return */, const TGetTableTypesReq& /* req */) { + return; + } + void GetColumns(TGetColumnsResp& /* _return */, const TGetColumnsReq& /* req */) { + return; + } + void GetFunctions(TGetFunctionsResp& /* _return */, const TGetFunctionsReq& /* req */) { + return; + } + void GetOperationStatus(TGetOperationStatusResp& /* _return */, const TGetOperationStatusReq& /* req */) { + return; + } + void CancelOperation(TCancelOperationResp& /* _return */, const TCancelOperationReq& /* req */) { + return; + } + void CloseOperation(TCloseOperationResp& /* _return */, const TCloseOperationReq& /* req */) { + return; + } + void GetResultSetMetadata(TGetResultSetMetadataResp& /* _return */, const TGetResultSetMetadataReq& /* req */) { + return; + } + void FetchResults(TFetchResultsResp& /* _return */, const TFetchResultsReq& /* req */) { + return; + } + void GetDelegationToken(TGetDelegationTokenResp& /* _return */, const TGetDelegationTokenReq& /* req */) { + return; + } + void CancelDelegationToken(TCancelDelegationTokenResp& /* _return */, const TCancelDelegationTokenReq& /* req */) { + return; + } + void RenewDelegationToken(TRenewDelegationTokenResp& /* _return */, const TRenewDelegationTokenReq& /* req */) { + return; + } +}; + +typedef struct _TCLIService_OpenSession_args__isset { + _TCLIService_OpenSession_args__isset() : req(false) {} + 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(); + TOpenSessionReq req; + + _TCLIService_OpenSession_args__isset __isset; + + void __set_req(const TOpenSessionReq& val); + + bool operator == (const TCLIService_OpenSession_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_OpenSession_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_OpenSession_args & ) const; + + 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(); + 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 :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(); + TOpenSessionResp success; + + _TCLIService_OpenSession_result__isset __isset; + + void __set_success(const TOpenSessionResp& val); + + bool operator == (const TCLIService_OpenSession_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_OpenSession_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_OpenSession_result & ) const; + + 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 :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(); + 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 :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(); + TCloseSessionReq req; + + _TCLIService_CloseSession_args__isset __isset; + + void __set_req(const TCloseSessionReq& val); + + bool operator == (const TCLIService_CloseSession_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_CloseSession_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CloseSession_args & ) const; + + 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(); + 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 :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(); + TCloseSessionResp success; + + _TCLIService_CloseSession_result__isset __isset; + + void __set_success(const TCloseSessionResp& val); + + bool operator == (const TCLIService_CloseSession_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_CloseSession_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CloseSession_result & ) const; + + 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 :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(); + 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 :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(); + TGetInfoReq req; + + _TCLIService_GetInfo_args__isset __isset; + + void __set_req(const TGetInfoReq& val); + + bool operator == (const TCLIService_GetInfo_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetInfo_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetInfo_args & ) const; + + 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(); + 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 :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(); + TGetInfoResp success; + + _TCLIService_GetInfo_result__isset __isset; + + void __set_success(const TGetInfoResp& val); + + bool operator == (const TCLIService_GetInfo_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetInfo_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetInfo_result & ) const; + + 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 :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(); + 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 :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(); + TExecuteStatementReq req; + + _TCLIService_ExecuteStatement_args__isset __isset; + + void __set_req(const TExecuteStatementReq& val); + + bool operator == (const TCLIService_ExecuteStatement_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_ExecuteStatement_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_ExecuteStatement_args & ) const; + + 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(); + 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 :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(); + TExecuteStatementResp success; + + _TCLIService_ExecuteStatement_result__isset __isset; + + void __set_success(const TExecuteStatementResp& val); + + bool operator == (const TCLIService_ExecuteStatement_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_ExecuteStatement_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_ExecuteStatement_result & ) const; + + 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 :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(); + 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 :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(); + TGetTypeInfoReq req; + + _TCLIService_GetTypeInfo_args__isset __isset; + + void __set_req(const TGetTypeInfoReq& val); + + bool operator == (const TCLIService_GetTypeInfo_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetTypeInfo_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetTypeInfo_args & ) const; + + 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(); + 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 :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(); + TGetTypeInfoResp success; + + _TCLIService_GetTypeInfo_result__isset __isset; + + void __set_success(const TGetTypeInfoResp& val); + + bool operator == (const TCLIService_GetTypeInfo_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetTypeInfo_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetTypeInfo_result & ) const; + + 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 :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(); + 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 :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(); + TGetCatalogsReq req; + + _TCLIService_GetCatalogs_args__isset __isset; + + void __set_req(const TGetCatalogsReq& val); + + bool operator == (const TCLIService_GetCatalogs_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetCatalogs_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetCatalogs_args & ) const; + + 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(); + 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 :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(); + TGetCatalogsResp success; + + _TCLIService_GetCatalogs_result__isset __isset; + + void __set_success(const TGetCatalogsResp& val); + + bool operator == (const TCLIService_GetCatalogs_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetCatalogs_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetCatalogs_result & ) const; + + 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 :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(); + 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 :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(); + TGetSchemasReq req; + + _TCLIService_GetSchemas_args__isset __isset; + + void __set_req(const TGetSchemasReq& val); + + bool operator == (const TCLIService_GetSchemas_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetSchemas_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetSchemas_args & ) const; + + 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(); + 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 :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(); + TGetSchemasResp success; + + _TCLIService_GetSchemas_result__isset __isset; + + void __set_success(const TGetSchemasResp& val); + + bool operator == (const TCLIService_GetSchemas_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetSchemas_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetSchemas_result & ) const; + + 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 :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(); + 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 :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(); + TGetTablesReq req; + + _TCLIService_GetTables_args__isset __isset; + + void __set_req(const TGetTablesReq& val); + + bool operator == (const TCLIService_GetTables_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetTables_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetTables_args & ) const; + + 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(); + 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 :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(); + TGetTablesResp success; + + _TCLIService_GetTables_result__isset __isset; + + void __set_success(const TGetTablesResp& val); + + bool operator == (const TCLIService_GetTables_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetTables_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetTables_result & ) const; + + 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 :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(); + 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 :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(); + TGetTableTypesReq req; + + _TCLIService_GetTableTypes_args__isset __isset; + + void __set_req(const TGetTableTypesReq& val); + + bool operator == (const TCLIService_GetTableTypes_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetTableTypes_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetTableTypes_args & ) const; + + 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(); + 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 :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(); + TGetTableTypesResp success; + + _TCLIService_GetTableTypes_result__isset __isset; + + void __set_success(const TGetTableTypesResp& val); + + bool operator == (const TCLIService_GetTableTypes_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetTableTypes_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetTableTypes_result & ) const; + + 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 :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(); + 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 :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(); + TGetColumnsReq req; + + _TCLIService_GetColumns_args__isset __isset; + + void __set_req(const TGetColumnsReq& val); + + bool operator == (const TCLIService_GetColumns_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetColumns_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetColumns_args & ) const; + + 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(); + 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 :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(); + TGetColumnsResp success; + + _TCLIService_GetColumns_result__isset __isset; + + void __set_success(const TGetColumnsResp& val); + + bool operator == (const TCLIService_GetColumns_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetColumns_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetColumns_result & ) const; + + 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 :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(); + 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 :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(); + TGetFunctionsReq req; + + _TCLIService_GetFunctions_args__isset __isset; + + void __set_req(const TGetFunctionsReq& val); + + bool operator == (const TCLIService_GetFunctions_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetFunctions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetFunctions_args & ) const; + + 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(); + 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 :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(); + TGetFunctionsResp success; + + _TCLIService_GetFunctions_result__isset __isset; + + void __set_success(const TGetFunctionsResp& val); + + bool operator == (const TCLIService_GetFunctions_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetFunctions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetFunctions_result & ) const; + + 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 :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(); + 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 :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(); + TGetOperationStatusReq req; + + _TCLIService_GetOperationStatus_args__isset __isset; + + void __set_req(const TGetOperationStatusReq& val); + + bool operator == (const TCLIService_GetOperationStatus_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetOperationStatus_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetOperationStatus_args & ) const; + + 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(); + 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 :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(); + TGetOperationStatusResp success; + + _TCLIService_GetOperationStatus_result__isset __isset; + + void __set_success(const TGetOperationStatusResp& val); + + bool operator == (const TCLIService_GetOperationStatus_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetOperationStatus_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetOperationStatus_result & ) const; + + 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 :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(); + 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 :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(); + TCancelOperationReq req; + + _TCLIService_CancelOperation_args__isset __isset; + + void __set_req(const TCancelOperationReq& val); + + bool operator == (const TCLIService_CancelOperation_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_CancelOperation_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CancelOperation_args & ) const; + + 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(); + 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 :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(); + TCancelOperationResp success; + + _TCLIService_CancelOperation_result__isset __isset; + + void __set_success(const TCancelOperationResp& val); + + bool operator == (const TCLIService_CancelOperation_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_CancelOperation_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CancelOperation_result & ) const; + + 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 :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(); + 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 :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(); + TCloseOperationReq req; + + _TCLIService_CloseOperation_args__isset __isset; + + void __set_req(const TCloseOperationReq& val); + + bool operator == (const TCLIService_CloseOperation_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_CloseOperation_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CloseOperation_args & ) const; + + 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(); + 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 :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(); + TCloseOperationResp success; + + _TCLIService_CloseOperation_result__isset __isset; + + void __set_success(const TCloseOperationResp& val); + + bool operator == (const TCLIService_CloseOperation_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_CloseOperation_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CloseOperation_result & ) const; + + 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 :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(); + 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 :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(); + TGetResultSetMetadataReq req; + + _TCLIService_GetResultSetMetadata_args__isset __isset; + + void __set_req(const TGetResultSetMetadataReq& val); + + bool operator == (const TCLIService_GetResultSetMetadata_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetResultSetMetadata_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetResultSetMetadata_args & ) const; + + 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(); + 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 :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(); + TGetResultSetMetadataResp success; + + _TCLIService_GetResultSetMetadata_result__isset __isset; + + void __set_success(const TGetResultSetMetadataResp& val); + + bool operator == (const TCLIService_GetResultSetMetadata_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetResultSetMetadata_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetResultSetMetadata_result & ) const; + + 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 :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(); + 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 :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(); + TFetchResultsReq req; + + _TCLIService_FetchResults_args__isset __isset; + + void __set_req(const TFetchResultsReq& val); + + bool operator == (const TCLIService_FetchResults_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_FetchResults_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_FetchResults_args & ) const; + + 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(); + 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 :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(); + TFetchResultsResp success; + + _TCLIService_FetchResults_result__isset __isset; + + void __set_success(const TFetchResultsResp& val); + + bool operator == (const TCLIService_FetchResults_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_FetchResults_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_FetchResults_result & ) const; + + 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 :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(); + 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 :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(); + TGetDelegationTokenReq req; + + _TCLIService_GetDelegationToken_args__isset __isset; + + void __set_req(const TGetDelegationTokenReq& val); + + bool operator == (const TCLIService_GetDelegationToken_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_GetDelegationToken_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetDelegationToken_args & ) const; + + 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(); + 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 :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(); + TGetDelegationTokenResp success; + + _TCLIService_GetDelegationToken_result__isset __isset; + + void __set_success(const TGetDelegationTokenResp& val); + + bool operator == (const TCLIService_GetDelegationToken_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_GetDelegationToken_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_GetDelegationToken_result & ) const; + + 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 :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(); + 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 :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(); + TCancelDelegationTokenReq req; + + _TCLIService_CancelDelegationToken_args__isset __isset; + + void __set_req(const TCancelDelegationTokenReq& val); + + bool operator == (const TCLIService_CancelDelegationToken_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_CancelDelegationToken_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CancelDelegationToken_args & ) const; + + 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(); + 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 :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(); + TCancelDelegationTokenResp success; + + _TCLIService_CancelDelegationToken_result__isset __isset; + + void __set_success(const TCancelDelegationTokenResp& val); + + bool operator == (const TCLIService_CancelDelegationToken_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_CancelDelegationToken_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_CancelDelegationToken_result & ) const; + + 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 :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(); + 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 :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(); + TRenewDelegationTokenReq req; + + _TCLIService_RenewDelegationToken_args__isset __isset; + + void __set_req(const TRenewDelegationTokenReq& val); + + bool operator == (const TCLIService_RenewDelegationToken_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const TCLIService_RenewDelegationToken_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_RenewDelegationToken_args & ) const; + + 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(); + 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 :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(); + TRenewDelegationTokenResp success; + + _TCLIService_RenewDelegationToken_result__isset __isset; + + void __set_success(const TRenewDelegationTokenResp& val); + + bool operator == (const TCLIService_RenewDelegationToken_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const TCLIService_RenewDelegationToken_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCLIService_RenewDelegationToken_result & ) const; + + 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 :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(); + 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) { + setProtocol(prot); + } + TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,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_; + } + boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req); + void send_OpenSession(const TOpenSessionReq& req); + void recv_OpenSession(TOpenSessionResp& _return); + void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req); + void send_CloseSession(const TCloseSessionReq& req); + void recv_CloseSession(TCloseSessionResp& _return); + void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req); + void send_GetInfo(const TGetInfoReq& req); + void recv_GetInfo(TGetInfoResp& _return); + void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req); + void send_ExecuteStatement(const TExecuteStatementReq& req); + void recv_ExecuteStatement(TExecuteStatementResp& _return); + void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req); + void send_GetTypeInfo(const TGetTypeInfoReq& req); + void recv_GetTypeInfo(TGetTypeInfoResp& _return); + void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req); + void send_GetCatalogs(const TGetCatalogsReq& req); + void recv_GetCatalogs(TGetCatalogsResp& _return); + void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req); + void send_GetSchemas(const TGetSchemasReq& req); + void recv_GetSchemas(TGetSchemasResp& _return); + void GetTables(TGetTablesResp& _return, const TGetTablesReq& req); + void send_GetTables(const TGetTablesReq& req); + void recv_GetTables(TGetTablesResp& _return); + void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req); + void send_GetTableTypes(const TGetTableTypesReq& req); + void recv_GetTableTypes(TGetTableTypesResp& _return); + void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req); + void send_GetColumns(const TGetColumnsReq& req); + void recv_GetColumns(TGetColumnsResp& _return); + void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req); + void send_GetFunctions(const TGetFunctionsReq& req); + void recv_GetFunctions(TGetFunctionsResp& _return); + void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req); + void send_GetOperationStatus(const TGetOperationStatusReq& req); + void recv_GetOperationStatus(TGetOperationStatusResp& _return);
<TRUNCATED>