/**
 * Autogenerated by Thrift Compiler (0.9.3)
 *
 * 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 <thrift/async/TConcurrentClientSyncInfo.h>
#include "TCLIService_types.h"

namespace apache { namespace hive { namespace service { namespace rpc { namespace thrift {

#ifdef _WIN32
  #pragma warning( push )
  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
#endif

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 GetPrimaryKeys(TGetPrimaryKeysResp& _return, const TGetPrimaryKeysReq& req) = 0;
  virtual void GetCrossReference(TGetCrossReferenceResp& _return, const TGetCrossReferenceReq& 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 GetPrimaryKeys(TGetPrimaryKeysResp& /* _return */, const TGetPrimaryKeysReq& /* req */) {
    return;
  }
  void GetCrossReference(TGetCrossReferenceResp& /* _return */, const TGetCrossReferenceReq& /* 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:

  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;

};


class TCLIService_OpenSession_pargs {
 public:


  virtual ~TCLIService_OpenSession_pargs() throw();
  const TOpenSessionReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_OpenSession_result__isset {
  _TCLIService_OpenSession_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_OpenSession_result__isset;

class TCLIService_OpenSession_result {
 public:

  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;

};

typedef struct _TCLIService_OpenSession_presult__isset {
  _TCLIService_OpenSession_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_OpenSession_presult__isset;

class TCLIService_OpenSession_presult {
 public:


  virtual ~TCLIService_OpenSession_presult() throw();
  TOpenSessionResp* success;

  _TCLIService_OpenSession_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CloseSession_args__isset {
  _TCLIService_CloseSession_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_CloseSession_args__isset;

class TCLIService_CloseSession_args {
 public:

  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;

};


class TCLIService_CloseSession_pargs {
 public:


  virtual ~TCLIService_CloseSession_pargs() throw();
  const TCloseSessionReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CloseSession_result__isset {
  _TCLIService_CloseSession_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_CloseSession_result__isset;

class TCLIService_CloseSession_result {
 public:

  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;

};

typedef struct _TCLIService_CloseSession_presult__isset {
  _TCLIService_CloseSession_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_CloseSession_presult__isset;

class TCLIService_CloseSession_presult {
 public:


  virtual ~TCLIService_CloseSession_presult() throw();
  TCloseSessionResp* success;

  _TCLIService_CloseSession_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetInfo_args__isset {
  _TCLIService_GetInfo_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetInfo_args__isset;

class TCLIService_GetInfo_args {
 public:

  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;

};


class TCLIService_GetInfo_pargs {
 public:


  virtual ~TCLIService_GetInfo_pargs() throw();
  const TGetInfoReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetInfo_result__isset {
  _TCLIService_GetInfo_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetInfo_result__isset;

class TCLIService_GetInfo_result {
 public:

  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;

};

typedef struct _TCLIService_GetInfo_presult__isset {
  _TCLIService_GetInfo_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetInfo_presult__isset;

class TCLIService_GetInfo_presult {
 public:


  virtual ~TCLIService_GetInfo_presult() throw();
  TGetInfoResp* success;

  _TCLIService_GetInfo_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_ExecuteStatement_args__isset {
  _TCLIService_ExecuteStatement_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_ExecuteStatement_args__isset;

class TCLIService_ExecuteStatement_args {
 public:

  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;

};


class TCLIService_ExecuteStatement_pargs {
 public:


  virtual ~TCLIService_ExecuteStatement_pargs() throw();
  const TExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_ExecuteStatement_result__isset {
  _TCLIService_ExecuteStatement_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_ExecuteStatement_result__isset;

class TCLIService_ExecuteStatement_result {
 public:

  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;

};

typedef struct _TCLIService_ExecuteStatement_presult__isset {
  _TCLIService_ExecuteStatement_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_ExecuteStatement_presult__isset;

class TCLIService_ExecuteStatement_presult {
 public:


  virtual ~TCLIService_ExecuteStatement_presult() throw();
  TExecuteStatementResp* success;

  _TCLIService_ExecuteStatement_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetTypeInfo_args__isset {
  _TCLIService_GetTypeInfo_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetTypeInfo_args__isset;

class TCLIService_GetTypeInfo_args {
 public:

  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;

};


class TCLIService_GetTypeInfo_pargs {
 public:


  virtual ~TCLIService_GetTypeInfo_pargs() throw();
  const TGetTypeInfoReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTypeInfo_result__isset {
  _TCLIService_GetTypeInfo_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetTypeInfo_result__isset;

class TCLIService_GetTypeInfo_result {
 public:

  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;

};

typedef struct _TCLIService_GetTypeInfo_presult__isset {
  _TCLIService_GetTypeInfo_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetTypeInfo_presult__isset;

class TCLIService_GetTypeInfo_presult {
 public:


  virtual ~TCLIService_GetTypeInfo_presult() throw();
  TGetTypeInfoResp* success;

  _TCLIService_GetTypeInfo_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetCatalogs_args__isset {
  _TCLIService_GetCatalogs_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetCatalogs_args__isset;

class TCLIService_GetCatalogs_args {
 public:

  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;

};


class TCLIService_GetCatalogs_pargs {
 public:


  virtual ~TCLIService_GetCatalogs_pargs() throw();
  const TGetCatalogsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetCatalogs_result__isset {
  _TCLIService_GetCatalogs_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetCatalogs_result__isset;

class TCLIService_GetCatalogs_result {
 public:

  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;

};

typedef struct _TCLIService_GetCatalogs_presult__isset {
  _TCLIService_GetCatalogs_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetCatalogs_presult__isset;

class TCLIService_GetCatalogs_presult {
 public:


  virtual ~TCLIService_GetCatalogs_presult() throw();
  TGetCatalogsResp* success;

  _TCLIService_GetCatalogs_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetSchemas_args__isset {
  _TCLIService_GetSchemas_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetSchemas_args__isset;

class TCLIService_GetSchemas_args {
 public:

  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;

};


class TCLIService_GetSchemas_pargs {
 public:


  virtual ~TCLIService_GetSchemas_pargs() throw();
  const TGetSchemasReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetSchemas_result__isset {
  _TCLIService_GetSchemas_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetSchemas_result__isset;

class TCLIService_GetSchemas_result {
 public:

  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;

};

typedef struct _TCLIService_GetSchemas_presult__isset {
  _TCLIService_GetSchemas_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetSchemas_presult__isset;

class TCLIService_GetSchemas_presult {
 public:


  virtual ~TCLIService_GetSchemas_presult() throw();
  TGetSchemasResp* success;

  _TCLIService_GetSchemas_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetTables_args__isset {
  _TCLIService_GetTables_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetTables_args__isset;

class TCLIService_GetTables_args {
 public:

  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;

};


class TCLIService_GetTables_pargs {
 public:


  virtual ~TCLIService_GetTables_pargs() throw();
  const TGetTablesReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTables_result__isset {
  _TCLIService_GetTables_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetTables_result__isset;

class TCLIService_GetTables_result {
 public:

  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;

};

typedef struct _TCLIService_GetTables_presult__isset {
  _TCLIService_GetTables_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetTables_presult__isset;

class TCLIService_GetTables_presult {
 public:


  virtual ~TCLIService_GetTables_presult() throw();
  TGetTablesResp* success;

  _TCLIService_GetTables_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetTableTypes_args__isset {
  _TCLIService_GetTableTypes_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetTableTypes_args__isset;

class TCLIService_GetTableTypes_args {
 public:

  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;

};


class TCLIService_GetTableTypes_pargs {
 public:


  virtual ~TCLIService_GetTableTypes_pargs() throw();
  const TGetTableTypesReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTableTypes_result__isset {
  _TCLIService_GetTableTypes_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetTableTypes_result__isset;

class TCLIService_GetTableTypes_result {
 public:

  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;

};

typedef struct _TCLIService_GetTableTypes_presult__isset {
  _TCLIService_GetTableTypes_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetTableTypes_presult__isset;

class TCLIService_GetTableTypes_presult {
 public:


  virtual ~TCLIService_GetTableTypes_presult() throw();
  TGetTableTypesResp* success;

  _TCLIService_GetTableTypes_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetColumns_args__isset {
  _TCLIService_GetColumns_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetColumns_args__isset;

class TCLIService_GetColumns_args {
 public:

  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;

};


class TCLIService_GetColumns_pargs {
 public:


  virtual ~TCLIService_GetColumns_pargs() throw();
  const TGetColumnsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetColumns_result__isset {
  _TCLIService_GetColumns_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetColumns_result__isset;

class TCLIService_GetColumns_result {
 public:

  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;

};

typedef struct _TCLIService_GetColumns_presult__isset {
  _TCLIService_GetColumns_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetColumns_presult__isset;

class TCLIService_GetColumns_presult {
 public:


  virtual ~TCLIService_GetColumns_presult() throw();
  TGetColumnsResp* success;

  _TCLIService_GetColumns_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetFunctions_args__isset {
  _TCLIService_GetFunctions_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetFunctions_args__isset;

class TCLIService_GetFunctions_args {
 public:

  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;

};


class TCLIService_GetFunctions_pargs {
 public:


  virtual ~TCLIService_GetFunctions_pargs() throw();
  const TGetFunctionsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetFunctions_result__isset {
  _TCLIService_GetFunctions_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetFunctions_result__isset;

class TCLIService_GetFunctions_result {
 public:

  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;

};

typedef struct _TCLIService_GetFunctions_presult__isset {
  _TCLIService_GetFunctions_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetFunctions_presult__isset;

class TCLIService_GetFunctions_presult {
 public:


  virtual ~TCLIService_GetFunctions_presult() throw();
  TGetFunctionsResp* success;

  _TCLIService_GetFunctions_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetPrimaryKeys_args__isset {
  _TCLIService_GetPrimaryKeys_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetPrimaryKeys_args__isset;

class TCLIService_GetPrimaryKeys_args {
 public:

  TCLIService_GetPrimaryKeys_args(const TCLIService_GetPrimaryKeys_args&);
  TCLIService_GetPrimaryKeys_args& operator=(const TCLIService_GetPrimaryKeys_args&);
  TCLIService_GetPrimaryKeys_args() {
  }

  virtual ~TCLIService_GetPrimaryKeys_args() throw();
  TGetPrimaryKeysReq req;

  _TCLIService_GetPrimaryKeys_args__isset __isset;

  void __set_req(const TGetPrimaryKeysReq& val);

  bool operator == (const TCLIService_GetPrimaryKeys_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetPrimaryKeys_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetPrimaryKeys_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetPrimaryKeys_pargs {
 public:


  virtual ~TCLIService_GetPrimaryKeys_pargs() throw();
  const TGetPrimaryKeysReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetPrimaryKeys_result__isset {
  _TCLIService_GetPrimaryKeys_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetPrimaryKeys_result__isset;

class TCLIService_GetPrimaryKeys_result {
 public:

  TCLIService_GetPrimaryKeys_result(const TCLIService_GetPrimaryKeys_result&);
  TCLIService_GetPrimaryKeys_result& operator=(const TCLIService_GetPrimaryKeys_result&);
  TCLIService_GetPrimaryKeys_result() {
  }

  virtual ~TCLIService_GetPrimaryKeys_result() throw();
  TGetPrimaryKeysResp success;

  _TCLIService_GetPrimaryKeys_result__isset __isset;

  void __set_success(const TGetPrimaryKeysResp& val);

  bool operator == (const TCLIService_GetPrimaryKeys_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetPrimaryKeys_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetPrimaryKeys_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetPrimaryKeys_presult__isset {
  _TCLIService_GetPrimaryKeys_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetPrimaryKeys_presult__isset;

class TCLIService_GetPrimaryKeys_presult {
 public:


  virtual ~TCLIService_GetPrimaryKeys_presult() throw();
  TGetPrimaryKeysResp* success;

  _TCLIService_GetPrimaryKeys_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetCrossReference_args__isset {
  _TCLIService_GetCrossReference_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetCrossReference_args__isset;

class TCLIService_GetCrossReference_args {
 public:

  TCLIService_GetCrossReference_args(const TCLIService_GetCrossReference_args&);
  TCLIService_GetCrossReference_args& operator=(const TCLIService_GetCrossReference_args&);
  TCLIService_GetCrossReference_args() {
  }

  virtual ~TCLIService_GetCrossReference_args() throw();
  TGetCrossReferenceReq req;

  _TCLIService_GetCrossReference_args__isset __isset;

  void __set_req(const TGetCrossReferenceReq& val);

  bool operator == (const TCLIService_GetCrossReference_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetCrossReference_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetCrossReference_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetCrossReference_pargs {
 public:


  virtual ~TCLIService_GetCrossReference_pargs() throw();
  const TGetCrossReferenceReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetCrossReference_result__isset {
  _TCLIService_GetCrossReference_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetCrossReference_result__isset;

class TCLIService_GetCrossReference_result {
 public:

  TCLIService_GetCrossReference_result(const TCLIService_GetCrossReference_result&);
  TCLIService_GetCrossReference_result& operator=(const TCLIService_GetCrossReference_result&);
  TCLIService_GetCrossReference_result() {
  }

  virtual ~TCLIService_GetCrossReference_result() throw();
  TGetCrossReferenceResp success;

  _TCLIService_GetCrossReference_result__isset __isset;

  void __set_success(const TGetCrossReferenceResp& val);

  bool operator == (const TCLIService_GetCrossReference_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetCrossReference_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetCrossReference_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetCrossReference_presult__isset {
  _TCLIService_GetCrossReference_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetCrossReference_presult__isset;

class TCLIService_GetCrossReference_presult {
 public:


  virtual ~TCLIService_GetCrossReference_presult() throw();
  TGetCrossReferenceResp* success;

  _TCLIService_GetCrossReference_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetOperationStatus_args__isset {
  _TCLIService_GetOperationStatus_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetOperationStatus_args__isset;

class TCLIService_GetOperationStatus_args {
 public:

  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;

};


class TCLIService_GetOperationStatus_pargs {
 public:


  virtual ~TCLIService_GetOperationStatus_pargs() throw();
  const TGetOperationStatusReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetOperationStatus_result__isset {
  _TCLIService_GetOperationStatus_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetOperationStatus_result__isset;

class TCLIService_GetOperationStatus_result {
 public:

  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;

};

typedef struct _TCLIService_GetOperationStatus_presult__isset {
  _TCLIService_GetOperationStatus_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetOperationStatus_presult__isset;

class TCLIService_GetOperationStatus_presult {
 public:


  virtual ~TCLIService_GetOperationStatus_presult() throw();
  TGetOperationStatusResp* success;

  _TCLIService_GetOperationStatus_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CancelOperation_args__isset {
  _TCLIService_CancelOperation_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_CancelOperation_args__isset;

class TCLIService_CancelOperation_args {
 public:

  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;

};


class TCLIService_CancelOperation_pargs {
 public:


  virtual ~TCLIService_CancelOperation_pargs() throw();
  const TCancelOperationReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CancelOperation_result__isset {
  _TCLIService_CancelOperation_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_CancelOperation_result__isset;

class TCLIService_CancelOperation_result {
 public:

  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;

};

typedef struct _TCLIService_CancelOperation_presult__isset {
  _TCLIService_CancelOperation_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_CancelOperation_presult__isset;

class TCLIService_CancelOperation_presult {
 public:


  virtual ~TCLIService_CancelOperation_presult() throw();
  TCancelOperationResp* success;

  _TCLIService_CancelOperation_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CloseOperation_args__isset {
  _TCLIService_CloseOperation_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_CloseOperation_args__isset;

class TCLIService_CloseOperation_args {
 public:

  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;

};


class TCLIService_CloseOperation_pargs {
 public:


  virtual ~TCLIService_CloseOperation_pargs() throw();
  const TCloseOperationReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CloseOperation_result__isset {
  _TCLIService_CloseOperation_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_CloseOperation_result__isset;

class TCLIService_CloseOperation_result {
 public:

  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;

};

typedef struct _TCLIService_CloseOperation_presult__isset {
  _TCLIService_CloseOperation_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_CloseOperation_presult__isset;

class TCLIService_CloseOperation_presult {
 public:


  virtual ~TCLIService_CloseOperation_presult() throw();
  TCloseOperationResp* success;

  _TCLIService_CloseOperation_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetResultSetMetadata_args__isset {
  _TCLIService_GetResultSetMetadata_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetResultSetMetadata_args__isset;

class TCLIService_GetResultSetMetadata_args {
 public:

  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;

};


class TCLIService_GetResultSetMetadata_pargs {
 public:


  virtual ~TCLIService_GetResultSetMetadata_pargs() throw();
  const TGetResultSetMetadataReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetResultSetMetadata_result__isset {
  _TCLIService_GetResultSetMetadata_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetResultSetMetadata_result__isset;

class TCLIService_GetResultSetMetadata_result {
 public:

  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;

};

typedef struct _TCLIService_GetResultSetMetadata_presult__isset {
  _TCLIService_GetResultSetMetadata_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetResultSetMetadata_presult__isset;

class TCLIService_GetResultSetMetadata_presult {
 public:


  virtual ~TCLIService_GetResultSetMetadata_presult() throw();
  TGetResultSetMetadataResp* success;

  _TCLIService_GetResultSetMetadata_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_FetchResults_args__isset {
  _TCLIService_FetchResults_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_FetchResults_args__isset;

class TCLIService_FetchResults_args {
 public:

  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;

};


class TCLIService_FetchResults_pargs {
 public:


  virtual ~TCLIService_FetchResults_pargs() throw();
  const TFetchResultsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_FetchResults_result__isset {
  _TCLIService_FetchResults_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_FetchResults_result__isset;

class TCLIService_FetchResults_result {
 public:

  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;

};

typedef struct _TCLIService_FetchResults_presult__isset {
  _TCLIService_FetchResults_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_FetchResults_presult__isset;

class TCLIService_FetchResults_presult {
 public:


  virtual ~TCLIService_FetchResults_presult() throw();
  TFetchResultsResp* success;

  _TCLIService_FetchResults_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetDelegationToken_args__isset {
  _TCLIService_GetDelegationToken_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_GetDelegationToken_args__isset;

class TCLIService_GetDelegationToken_args {
 public:

  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;

};


class TCLIService_GetDelegationToken_pargs {
 public:


  virtual ~TCLIService_GetDelegationToken_pargs() throw();
  const TGetDelegationTokenReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetDelegationToken_result__isset {
  _TCLIService_GetDelegationToken_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetDelegationToken_result__isset;

class TCLIService_GetDelegationToken_result {
 public:

  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;

};

typedef struct _TCLIService_GetDelegationToken_presult__isset {
  _TCLIService_GetDelegationToken_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_GetDelegationToken_presult__isset;

class TCLIService_GetDelegationToken_presult {
 public:


  virtual ~TCLIService_GetDelegationToken_presult() throw();
  TGetDelegationTokenResp* success;

  _TCLIService_GetDelegationToken_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CancelDelegationToken_args__isset {
  _TCLIService_CancelDelegationToken_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_CancelDelegationToken_args__isset;

class TCLIService_CancelDelegationToken_args {
 public:

  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;

};


class TCLIService_CancelDelegationToken_pargs {
 public:


  virtual ~TCLIService_CancelDelegationToken_pargs() throw();
  const TCancelDelegationTokenReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CancelDelegationToken_result__isset {
  _TCLIService_CancelDelegationToken_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_CancelDelegationToken_result__isset;

class TCLIService_CancelDelegationToken_result {
 public:

  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;

};

typedef struct _TCLIService_CancelDelegationToken_presult__isset {
  _TCLIService_CancelDelegationToken_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_CancelDelegationToken_presult__isset;

class TCLIService_CancelDelegationToken_presult {
 public:


  virtual ~TCLIService_CancelDelegationToken_presult() throw();
  TCancelDelegationTokenResp* success;

  _TCLIService_CancelDelegationToken_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_RenewDelegationToken_args__isset {
  _TCLIService_RenewDelegationToken_args__isset() : req(false) {}
  bool req :1;
} _TCLIService_RenewDelegationToken_args__isset;

class TCLIService_RenewDelegationToken_args {
 public:

  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;

};


class TCLIService_RenewDelegationToken_pargs {
 public:


  virtual ~TCLIService_RenewDelegationToken_pargs() throw();
  const TRenewDelegationTokenReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_RenewDelegationToken_result__isset {
  _TCLIService_RenewDelegationToken_result__isset() : success(false) {}
  bool success :1;
} _TCLIService_RenewDelegationToken_result__isset;

class TCLIService_RenewDelegationToken_result {
 public:

  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;

};

typedef struct _TCLIService_RenewDelegationToken_presult__isset {
  _TCLIService_RenewDelegationToken_presult__isset() : success(false) {}
  bool success :1;
} _TCLIService_RenewDelegationToken_presult__isset;

class TCLIService_RenewDelegationToken_presult {
 public:


  virtual ~TCLIService_RenewDelegationToken_presult() throw();
  TRenewDelegationTokenResp* success;

  _TCLIService_RenewDelegationToken_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

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 GetPrimaryKeys(TGetPrimaryKeysResp& _return, const TGetPrimaryKeysReq& req);
  void send_GetPrimaryKeys(const TGetPrimaryKeysReq& req);
  void recv_GetPrimaryKeys(TGetPrimaryKeysResp& _return);
  void GetCrossReference(TGetCrossReferenceResp& _return, const TGetCrossReferenceReq& req);
  void send_GetCrossReference(const TGetCrossReferenceReq& req);
  void recv_GetCrossReference(TGetCrossReferenceResp& _return);
  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req);
  void send_GetOperationStatus(const TGetOperationStatusReq& req);
  void recv_GetOperationStatus(TGetOperationStatusResp& _return);
  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req);
  void send_CancelOperation(const TCancelOperationReq& req);
  void recv_CancelOperation(TCancelOperationResp& _return);
  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req);
  void send_CloseOperation(const TCloseOperationReq& req);
  void recv_CloseOperation(TCloseOperationResp& _return);
  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req);
  void send_GetResultSetMetadata(const TGetResultSetMetadataReq& req);
  void recv_GetResultSetMetadata(TGetResultSetMetadataResp& _return);
  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req);
  void send_FetchResults(const TFetchResultsReq& req);
  void recv_FetchResults(TFetchResultsResp& _return);
  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req);
  void send_GetDelegationToken(const TGetDelegationTokenReq& req);
  void recv_GetDelegationToken(TGetDelegationTokenResp& _return);
  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req);
  void send_CancelDelegationToken(const TCancelDelegationTokenReq& req);
  void recv_CancelDelegationToken(TCancelDelegationTokenResp& _return);
  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req);
  void send_RenewDelegationToken(const TRenewDelegationTokenReq& req);
  void recv_RenewDelegationToken(TRenewDelegationTokenResp& _return);
 protected:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class TCLIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  boost::shared_ptr<TCLIServiceIf> iface_;
  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
 private:
  typedef  void (TCLIServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_OpenSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CloseSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_ExecuteStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetTypeInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetCatalogs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetSchemas(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetTableTypes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetFunctions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetPrimaryKeys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetCrossReference(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetOperationStatus(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CancelOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CloseOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetResultSetMetadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_FetchResults(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CancelDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_RenewDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  TCLIServiceProcessor(boost::shared_ptr<TCLIServiceIf> iface) :
    iface_(iface) {
    processMap_["OpenSession"] = &TCLIServiceProcessor::process_OpenSession;
    processMap_["CloseSession"] = &TCLIServiceProcessor::process_CloseSession;
    processMap_["GetInfo"] = &TCLIServiceProcessor::process_GetInfo;
    processMap_["ExecuteStatement"] = &TCLIServiceProcessor::process_ExecuteStatement;
    processMap_["GetTypeInfo"] = &TCLIServiceProcessor::process_GetTypeInfo;
    processMap_["GetCatalogs"] = &TCLIServiceProcessor::process_GetCatalogs;
    processMap_["GetSchemas"] = &TCLIServiceProcessor::process_GetSchemas;
    processMap_["GetTables"] = &TCLIServiceProcessor::process_GetTables;
    processMap_["GetTableTypes"] = &TCLIServiceProcessor::process_GetTableTypes;
    processMap_["GetColumns"] = &TCLIServiceProcessor::process_GetColumns;
    processMap_["GetFunctions"] = &TCLIServiceProcessor::process_GetFunctions;
    processMap_["GetPrimaryKeys"] = &TCLIServiceProcessor::process_GetPrimaryKeys;
    processMap_["GetCrossReference"] = &TCLIServiceProcessor::process_GetCrossReference;
    processMap_["GetOperationStatus"] = &TCLIServiceProcessor::process_GetOperationStatus;
    processMap_["CancelOperation"] = &TCLIServiceProcessor::process_CancelOperation;
    processMap_["CloseOperation"] = &TCLIServiceProcessor::process_CloseOperation;
    processMap_["GetResultSetMetadata"] = &TCLIServiceProcessor::process_GetResultSetMetadata;
    processMap_["FetchResults"] = &TCLIServiceProcessor::process_FetchResults;
    processMap_["GetDelegationToken"] = &TCLIServiceProcessor::process_GetDelegationToken;
    processMap_["CancelDelegationToken"] = &TCLIServiceProcessor::process_CancelDelegationToken;
    processMap_["RenewDelegationToken"] = &TCLIServiceProcessor::process_RenewDelegationToken;
  }

  virtual ~TCLIServiceProcessor() {}
};

class TCLIServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  TCLIServiceProcessorFactory(const ::boost::shared_ptr< TCLIServiceIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

  ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);

 protected:
  ::boost::shared_ptr< TCLIServiceIfFactory > handlerFactory_;
};

class TCLIServiceMultiface : virtual public TCLIServiceIf {
 public:
  TCLIServiceMultiface(std::vector<boost::shared_ptr<TCLIServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~TCLIServiceMultiface() {}
 protected:
  std::vector<boost::shared_ptr<TCLIServiceIf> > ifaces_;
  TCLIServiceMultiface() {}
  void add(boost::shared_ptr<TCLIServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->OpenSession(_return, req);
    }
    ifaces_[i]->OpenSession(_return, req);
    return;
  }

  void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CloseSession(_return, req);
    }
    ifaces_[i]->CloseSession(_return, req);
    return;
  }

  void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetInfo(_return, req);
    }
    ifaces_[i]->GetInfo(_return, req);
    return;
  }

  void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->ExecuteStatement(_return, req);
    }
    ifaces_[i]->ExecuteStatement(_return, req);
    return;
  }

  void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetTypeInfo(_return, req);
    }
    ifaces_[i]->GetTypeInfo(_return, req);
    return;
  }

  void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetCatalogs(_return, req);
    }
    ifaces_[i]->GetCatalogs(_return, req);
    return;
  }

  void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetSchemas(_return, req);
    }
    ifaces_[i]->GetSchemas(_return, req);
    return;
  }

  void GetTables(TGetTablesResp& _return, const TGetTablesReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetTables(_return, req);
    }
    ifaces_[i]->GetTables(_return, req);
    return;
  }

  void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetTableTypes(_return, req);
    }
    ifaces_[i]->GetTableTypes(_return, req);
    return;
  }

  void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetColumns(_return, req);
    }
    ifaces_[i]->GetColumns(_return, req);
    return;
  }

  void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetFunctions(_return, req);
    }
    ifaces_[i]->GetFunctions(_return, req);
    return;
  }

  void GetPrimaryKeys(TGetPrimaryKeysResp& _return, const TGetPrimaryKeysReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetPrimaryKeys(_return, req);
    }
    ifaces_[i]->GetPrimaryKeys(_return, req);
    return;
  }

  void GetCrossReference(TGetCrossReferenceResp& _return, const TGetCrossReferenceReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetCrossReference(_return, req);
    }
    ifaces_[i]->GetCrossReference(_return, req);
    return;
  }

  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetOperationStatus(_return, req);
    }
    ifaces_[i]->GetOperationStatus(_return, req);
    return;
  }

  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CancelOperation(_return, req);
    }
    ifaces_[i]->CancelOperation(_return, req);
    return;
  }

  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CloseOperation(_return, req);
    }
    ifaces_[i]->CloseOperation(_return, req);
    return;
  }

  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetResultSetMetadata(_return, req);
    }
    ifaces_[i]->GetResultSetMetadata(_return, req);
    return;
  }

  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->FetchResults(_return, req);
    }
    ifaces_[i]->FetchResults(_return, req);
    return;
  }

  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetDelegationToken(_return, req);
    }
    ifaces_[i]->GetDelegationToken(_return, req);
    return;
  }

  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CancelDelegationToken(_return, req);
    }
    ifaces_[i]->CancelDelegationToken(_return, req);
    return;
  }

  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->RenewDelegationToken(_return, req);
    }
    ifaces_[i]->RenewDelegationToken(_return, req);
    return;
  }

};

// The 'concurrent' client is a thread safe client that correctly handles
// out of order responses.  It is slower than the regular client, so should
// only be used when you need to share a connection among multiple threads
class TCLIServiceConcurrentClient : virtual public TCLIServiceIf {
 public:
  TCLIServiceConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  TCLIServiceConcurrentClient(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);
  int32_t send_OpenSession(const TOpenSessionReq& req);
  void recv_OpenSession(TOpenSessionResp& _return, const int32_t seqid);
  void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req);
  int32_t send_CloseSession(const TCloseSessionReq& req);
  void recv_CloseSession(TCloseSessionResp& _return, const int32_t seqid);
  void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req);
  int32_t send_GetInfo(const TGetInfoReq& req);
  void recv_GetInfo(TGetInfoResp& _return, const int32_t seqid);
  void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req);
  int32_t send_ExecuteStatement(const TExecuteStatementReq& req);
  void recv_ExecuteStatement(TExecuteStatementResp& _return, const int32_t seqid);
  void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req);
  int32_t send_GetTypeInfo(const TGetTypeInfoReq& req);
  void recv_GetTypeInfo(TGetTypeInfoResp& _return, const int32_t seqid);
  void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req);
  int32_t send_GetCatalogs(const TGetCatalogsReq& req);
  void recv_GetCatalogs(TGetCatalogsResp& _return, const int32_t seqid);
  void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req);
  int32_t send_GetSchemas(const TGetSchemasReq& req);
  void recv_GetSchemas(TGetSchemasResp& _return, const int32_t seqid);
  void GetTables(TGetTablesResp& _return, const TGetTablesReq& req);
  int32_t send_GetTables(const TGetTablesReq& req);
  void recv_GetTables(TGetTablesResp& _return, const int32_t seqid);
  void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req);
  int32_t send_GetTableTypes(const TGetTableTypesReq& req);
  void recv_GetTableTypes(TGetTableTypesResp& _return, const int32_t seqid);
  void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req);
  int32_t send_GetColumns(const TGetColumnsReq& req);
  void recv_GetColumns(TGetColumnsResp& _return, const int32_t seqid);
  void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req);
  int32_t send_GetFunctions(const TGetFunctionsReq& req);
  void recv_GetFunctions(TGetFunctionsResp& _return, const int32_t seqid);
  void GetPrimaryKeys(TGetPrimaryKeysResp& _return, const TGetPrimaryKeysReq& req);
  int32_t send_GetPrimaryKeys(const TGetPrimaryKeysReq& req);
  void recv_GetPrimaryKeys(TGetPrimaryKeysResp& _return, const int32_t seqid);
  void GetCrossReference(TGetCrossReferenceResp& _return, const TGetCrossReferenceReq& req);
  int32_t send_GetCrossReference(const TGetCrossReferenceReq& req);
  void recv_GetCrossReference(TGetCrossReferenceResp& _return, const int32_t seqid);
  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req);
  int32_t send_GetOperationStatus(const TGetOperationStatusReq& req);
  void recv_GetOperationStatus(TGetOperationStatusResp& _return, const int32_t seqid);
  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req);
  int32_t send_CancelOperation(const TCancelOperationReq& req);
  void recv_CancelOperation(TCancelOperationResp& _return, const int32_t seqid);
  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req);
  int32_t send_CloseOperation(const TCloseOperationReq& req);
  void recv_CloseOperation(TCloseOperationResp& _return, const int32_t seqid);
  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req);
  int32_t send_GetResultSetMetadata(const TGetResultSetMetadataReq& req);
  void recv_GetResultSetMetadata(TGetResultSetMetadataResp& _return, const int32_t seqid);
  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req);
  int32_t send_FetchResults(const TFetchResultsReq& req);
  void recv_FetchResults(TFetchResultsResp& _return, const int32_t seqid);
  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req);
  int32_t send_GetDelegationToken(const TGetDelegationTokenReq& req);
  void recv_GetDelegationToken(TGetDelegationTokenResp& _return, const int32_t seqid);
  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req);
  int32_t send_CancelDelegationToken(const TCancelDelegationTokenReq& req);
  void recv_CancelDelegationToken(TCancelDelegationTokenResp& _return, const int32_t seqid);
  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req);
  int32_t send_RenewDelegationToken(const TRenewDelegationTokenReq& req);
  void recv_RenewDelegationToken(TRenewDelegationTokenResp& _return, const int32_t seqid);
 protected:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
  ::apache::thrift::async::TConcurrentClientSyncInfo sync_;
};

#ifdef _WIN32
  #pragma warning( pop )
#endif

}}}}} // namespace

#endif
