/**
 * Autogenerated by Thrift Compiler (0.14.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef TSIService_H
#define TSIService_H

#include <thrift/TDispatchProcessor.h>
#include <thrift/async/TConcurrentClientSyncInfo.h>
#include <memory>
#include "rpc_types.h"



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

class TSIServiceIf {
 public:
  virtual ~TSIServiceIf() {}
  virtual void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& req) = 0;
  virtual void closeSession(TSStatus& _return, const TSCloseSessionReq& req) = 0;
  virtual void executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void executeBatchStatement(TSStatus& _return, const TSExecuteBatchStatementReq& req) = 0;
  virtual void executeQueryStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void executeUpdateStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req) = 0;
  virtual void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& req) = 0;
  virtual void fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req) = 0;
  virtual void cancelOperation(TSStatus& _return, const TSCancelOperationReq& req) = 0;
  virtual void closeOperation(TSStatus& _return, const TSCloseOperationReq& req) = 0;
  virtual void getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId) = 0;
  virtual void setTimeZone(TSStatus& _return, const TSSetTimeZoneReq& req) = 0;
  virtual void getProperties(ServerProperties& _return) = 0;
  virtual void setStorageGroup(TSStatus& _return, const int64_t sessionId, const std::string& storageGroup) = 0;
  virtual void createTimeseries(TSStatus& _return, const TSCreateTimeseriesReq& req) = 0;
  virtual void createMultiTimeseries(TSStatus& _return, const TSCreateMultiTimeseriesReq& req) = 0;
  virtual void deleteTimeseries(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path) = 0;
  virtual void deleteStorageGroups(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup) = 0;
  virtual void insertRecord(TSStatus& _return, const TSInsertRecordReq& req) = 0;
  virtual void insertStringRecord(TSStatus& _return, const TSInsertStringRecordReq& req) = 0;
  virtual void insertTablet(TSStatus& _return, const TSInsertTabletReq& req) = 0;
  virtual void insertTablets(TSStatus& _return, const TSInsertTabletsReq& req) = 0;
  virtual void insertRecords(TSStatus& _return, const TSInsertRecordsReq& req) = 0;
  virtual void insertRecordsOfOneDevice(TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req) = 0;
  virtual void insertStringRecords(TSStatus& _return, const TSInsertStringRecordsReq& req) = 0;
  virtual void testInsertTablet(TSStatus& _return, const TSInsertTabletReq& req) = 0;
  virtual void testInsertTablets(TSStatus& _return, const TSInsertTabletsReq& req) = 0;
  virtual void testInsertRecord(TSStatus& _return, const TSInsertRecordReq& req) = 0;
  virtual void testInsertStringRecord(TSStatus& _return, const TSInsertStringRecordReq& req) = 0;
  virtual void testInsertRecords(TSStatus& _return, const TSInsertRecordsReq& req) = 0;
  virtual void testInsertRecordsOfOneDevice(TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req) = 0;
  virtual void testInsertStringRecords(TSStatus& _return, const TSInsertStringRecordsReq& req) = 0;
  virtual void deleteData(TSStatus& _return, const TSDeleteDataReq& req) = 0;
  virtual void executeRawDataQuery(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req) = 0;
  virtual int64_t requestStatementId(const int64_t sessionId) = 0;
};

class TSIServiceIfFactory {
 public:
  typedef TSIServiceIf Handler;

  virtual ~TSIServiceIfFactory() {}

  virtual TSIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  virtual void releaseHandler(TSIServiceIf* /* handler */) = 0;
};

class TSIServiceIfSingletonFactory : virtual public TSIServiceIfFactory {
 public:
  TSIServiceIfSingletonFactory(const ::std::shared_ptr<TSIServiceIf>& iface) : iface_(iface) {}
  virtual ~TSIServiceIfSingletonFactory() {}

  virtual TSIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
    return iface_.get();
  }
  virtual void releaseHandler(TSIServiceIf* /* handler */) {}

 protected:
  ::std::shared_ptr<TSIServiceIf> iface_;
};

class TSIServiceNull : virtual public TSIServiceIf {
 public:
  virtual ~TSIServiceNull() {}
  void openSession(TSOpenSessionResp& /* _return */, const TSOpenSessionReq& /* req */) {
    return;
  }
  void closeSession(TSStatus& /* _return */, const TSCloseSessionReq& /* req */) {
    return;
  }
  void executeStatement(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void executeBatchStatement(TSStatus& /* _return */, const TSExecuteBatchStatementReq& /* req */) {
    return;
  }
  void executeQueryStatement(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void executeUpdateStatement(TSExecuteStatementResp& /* _return */, const TSExecuteStatementReq& /* req */) {
    return;
  }
  void fetchResults(TSFetchResultsResp& /* _return */, const TSFetchResultsReq& /* req */) {
    return;
  }
  void fetchMetadata(TSFetchMetadataResp& /* _return */, const TSFetchMetadataReq& /* req */) {
    return;
  }
  void cancelOperation(TSStatus& /* _return */, const TSCancelOperationReq& /* req */) {
    return;
  }
  void closeOperation(TSStatus& /* _return */, const TSCloseOperationReq& /* req */) {
    return;
  }
  void getTimeZone(TSGetTimeZoneResp& /* _return */, const int64_t /* sessionId */) {
    return;
  }
  void setTimeZone(TSStatus& /* _return */, const TSSetTimeZoneReq& /* req */) {
    return;
  }
  void getProperties(ServerProperties& /* _return */) {
    return;
  }
  void setStorageGroup(TSStatus& /* _return */, const int64_t /* sessionId */, const std::string& /* storageGroup */) {
    return;
  }
  void createTimeseries(TSStatus& /* _return */, const TSCreateTimeseriesReq& /* req */) {
    return;
  }
  void createMultiTimeseries(TSStatus& /* _return */, const TSCreateMultiTimeseriesReq& /* req */) {
    return;
  }
  void deleteTimeseries(TSStatus& /* _return */, const int64_t /* sessionId */, const std::vector<std::string> & /* path */) {
    return;
  }
  void deleteStorageGroups(TSStatus& /* _return */, const int64_t /* sessionId */, const std::vector<std::string> & /* storageGroup */) {
    return;
  }
  void insertRecord(TSStatus& /* _return */, const TSInsertRecordReq& /* req */) {
    return;
  }
  void insertStringRecord(TSStatus& /* _return */, const TSInsertStringRecordReq& /* req */) {
    return;
  }
  void insertTablet(TSStatus& /* _return */, const TSInsertTabletReq& /* req */) {
    return;
  }
  void insertTablets(TSStatus& /* _return */, const TSInsertTabletsReq& /* req */) {
    return;
  }
  void insertRecords(TSStatus& /* _return */, const TSInsertRecordsReq& /* req */) {
    return;
  }
  void insertRecordsOfOneDevice(TSStatus& /* _return */, const TSInsertRecordsOfOneDeviceReq& /* req */) {
    return;
  }
  void insertStringRecords(TSStatus& /* _return */, const TSInsertStringRecordsReq& /* req */) {
    return;
  }
  void testInsertTablet(TSStatus& /* _return */, const TSInsertTabletReq& /* req */) {
    return;
  }
  void testInsertTablets(TSStatus& /* _return */, const TSInsertTabletsReq& /* req */) {
    return;
  }
  void testInsertRecord(TSStatus& /* _return */, const TSInsertRecordReq& /* req */) {
    return;
  }
  void testInsertStringRecord(TSStatus& /* _return */, const TSInsertStringRecordReq& /* req */) {
    return;
  }
  void testInsertRecords(TSStatus& /* _return */, const TSInsertRecordsReq& /* req */) {
    return;
  }
  void testInsertRecordsOfOneDevice(TSStatus& /* _return */, const TSInsertRecordsOfOneDeviceReq& /* req */) {
    return;
  }
  void testInsertStringRecords(TSStatus& /* _return */, const TSInsertStringRecordsReq& /* req */) {
    return;
  }
  void deleteData(TSStatus& /* _return */, const TSDeleteDataReq& /* req */) {
    return;
  }
  void executeRawDataQuery(TSExecuteStatementResp& /* _return */, const TSRawDataQueryReq& /* req */) {
    return;
  }
  int64_t requestStatementId(const int64_t /* sessionId */) {
    int64_t _return = 0;
    return _return;
  }
};

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

class TSIService_openSession_args {
 public:

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

  virtual ~TSIService_openSession_args() noexcept;
  TSOpenSessionReq req;

  _TSIService_openSession_args__isset __isset;

  void __set_req(const TSOpenSessionReq& val);

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

  bool operator < (const TSIService_openSession_args & ) const;

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

};


class TSIService_openSession_pargs {
 public:


  virtual ~TSIService_openSession_pargs() noexcept;
  const TSOpenSessionReq* req;

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

};

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

class TSIService_openSession_result {
 public:

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

  virtual ~TSIService_openSession_result() noexcept;
  TSOpenSessionResp success;

  _TSIService_openSession_result__isset __isset;

  void __set_success(const TSOpenSessionResp& val);

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

  bool operator < (const TSIService_openSession_result & ) const;

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

};

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

class TSIService_openSession_presult {
 public:


  virtual ~TSIService_openSession_presult() noexcept;
  TSOpenSessionResp* success;

  _TSIService_openSession_presult__isset __isset;

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

};

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

class TSIService_closeSession_args {
 public:

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

  virtual ~TSIService_closeSession_args() noexcept;
  TSCloseSessionReq req;

  _TSIService_closeSession_args__isset __isset;

  void __set_req(const TSCloseSessionReq& val);

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

  bool operator < (const TSIService_closeSession_args & ) const;

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

};


class TSIService_closeSession_pargs {
 public:


  virtual ~TSIService_closeSession_pargs() noexcept;
  const TSCloseSessionReq* req;

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

};

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

class TSIService_closeSession_result {
 public:

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

  virtual ~TSIService_closeSession_result() noexcept;
  TSStatus success;

  _TSIService_closeSession_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_closeSession_result & ) const;

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

};

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

class TSIService_closeSession_presult {
 public:


  virtual ~TSIService_closeSession_presult() noexcept;
  TSStatus* success;

  _TSIService_closeSession_presult__isset __isset;

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

};

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

class TSIService_executeStatement_args {
 public:

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

  virtual ~TSIService_executeStatement_args() noexcept;
  TSExecuteStatementReq req;

  _TSIService_executeStatement_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

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

  bool operator < (const TSIService_executeStatement_args & ) const;

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

};


class TSIService_executeStatement_pargs {
 public:


  virtual ~TSIService_executeStatement_pargs() noexcept;
  const TSExecuteStatementReq* req;

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

};

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

class TSIService_executeStatement_result {
 public:

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

  virtual ~TSIService_executeStatement_result() noexcept;
  TSExecuteStatementResp success;

  _TSIService_executeStatement_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

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

  bool operator < (const TSIService_executeStatement_result & ) const;

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

};

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

class TSIService_executeStatement_presult {
 public:


  virtual ~TSIService_executeStatement_presult() noexcept;
  TSExecuteStatementResp* success;

  _TSIService_executeStatement_presult__isset __isset;

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

};

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

class TSIService_executeBatchStatement_args {
 public:

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

  virtual ~TSIService_executeBatchStatement_args() noexcept;
  TSExecuteBatchStatementReq req;

  _TSIService_executeBatchStatement_args__isset __isset;

  void __set_req(const TSExecuteBatchStatementReq& val);

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

  bool operator < (const TSIService_executeBatchStatement_args & ) const;

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

};


class TSIService_executeBatchStatement_pargs {
 public:


  virtual ~TSIService_executeBatchStatement_pargs() noexcept;
  const TSExecuteBatchStatementReq* req;

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

};

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

class TSIService_executeBatchStatement_result {
 public:

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

  virtual ~TSIService_executeBatchStatement_result() noexcept;
  TSStatus success;

  _TSIService_executeBatchStatement_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_executeBatchStatement_result & ) const;

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

};

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

class TSIService_executeBatchStatement_presult {
 public:


  virtual ~TSIService_executeBatchStatement_presult() noexcept;
  TSStatus* success;

  _TSIService_executeBatchStatement_presult__isset __isset;

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

};

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

class TSIService_executeQueryStatement_args {
 public:

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

  virtual ~TSIService_executeQueryStatement_args() noexcept;
  TSExecuteStatementReq req;

  _TSIService_executeQueryStatement_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

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

  bool operator < (const TSIService_executeQueryStatement_args & ) const;

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

};


class TSIService_executeQueryStatement_pargs {
 public:


  virtual ~TSIService_executeQueryStatement_pargs() noexcept;
  const TSExecuteStatementReq* req;

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

};

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

class TSIService_executeQueryStatement_result {
 public:

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

  virtual ~TSIService_executeQueryStatement_result() noexcept;
  TSExecuteStatementResp success;

  _TSIService_executeQueryStatement_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

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

  bool operator < (const TSIService_executeQueryStatement_result & ) const;

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

};

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

class TSIService_executeQueryStatement_presult {
 public:


  virtual ~TSIService_executeQueryStatement_presult() noexcept;
  TSExecuteStatementResp* success;

  _TSIService_executeQueryStatement_presult__isset __isset;

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

};

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

class TSIService_executeUpdateStatement_args {
 public:

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

  virtual ~TSIService_executeUpdateStatement_args() noexcept;
  TSExecuteStatementReq req;

  _TSIService_executeUpdateStatement_args__isset __isset;

  void __set_req(const TSExecuteStatementReq& val);

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

  bool operator < (const TSIService_executeUpdateStatement_args & ) const;

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

};


class TSIService_executeUpdateStatement_pargs {
 public:


  virtual ~TSIService_executeUpdateStatement_pargs() noexcept;
  const TSExecuteStatementReq* req;

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

};

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

class TSIService_executeUpdateStatement_result {
 public:

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

  virtual ~TSIService_executeUpdateStatement_result() noexcept;
  TSExecuteStatementResp success;

  _TSIService_executeUpdateStatement_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

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

  bool operator < (const TSIService_executeUpdateStatement_result & ) const;

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

};

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

class TSIService_executeUpdateStatement_presult {
 public:


  virtual ~TSIService_executeUpdateStatement_presult() noexcept;
  TSExecuteStatementResp* success;

  _TSIService_executeUpdateStatement_presult__isset __isset;

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

};

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

class TSIService_fetchResults_args {
 public:

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

  virtual ~TSIService_fetchResults_args() noexcept;
  TSFetchResultsReq req;

  _TSIService_fetchResults_args__isset __isset;

  void __set_req(const TSFetchResultsReq& val);

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

  bool operator < (const TSIService_fetchResults_args & ) const;

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

};


class TSIService_fetchResults_pargs {
 public:


  virtual ~TSIService_fetchResults_pargs() noexcept;
  const TSFetchResultsReq* req;

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

};

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

class TSIService_fetchResults_result {
 public:

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

  virtual ~TSIService_fetchResults_result() noexcept;
  TSFetchResultsResp success;

  _TSIService_fetchResults_result__isset __isset;

  void __set_success(const TSFetchResultsResp& val);

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

  bool operator < (const TSIService_fetchResults_result & ) const;

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

};

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

class TSIService_fetchResults_presult {
 public:


  virtual ~TSIService_fetchResults_presult() noexcept;
  TSFetchResultsResp* success;

  _TSIService_fetchResults_presult__isset __isset;

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

};

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

class TSIService_fetchMetadata_args {
 public:

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

  virtual ~TSIService_fetchMetadata_args() noexcept;
  TSFetchMetadataReq req;

  _TSIService_fetchMetadata_args__isset __isset;

  void __set_req(const TSFetchMetadataReq& val);

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

  bool operator < (const TSIService_fetchMetadata_args & ) const;

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

};


class TSIService_fetchMetadata_pargs {
 public:


  virtual ~TSIService_fetchMetadata_pargs() noexcept;
  const TSFetchMetadataReq* req;

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

};

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

class TSIService_fetchMetadata_result {
 public:

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

  virtual ~TSIService_fetchMetadata_result() noexcept;
  TSFetchMetadataResp success;

  _TSIService_fetchMetadata_result__isset __isset;

  void __set_success(const TSFetchMetadataResp& val);

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

  bool operator < (const TSIService_fetchMetadata_result & ) const;

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

};

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

class TSIService_fetchMetadata_presult {
 public:


  virtual ~TSIService_fetchMetadata_presult() noexcept;
  TSFetchMetadataResp* success;

  _TSIService_fetchMetadata_presult__isset __isset;

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

};

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

class TSIService_cancelOperation_args {
 public:

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

  virtual ~TSIService_cancelOperation_args() noexcept;
  TSCancelOperationReq req;

  _TSIService_cancelOperation_args__isset __isset;

  void __set_req(const TSCancelOperationReq& val);

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

  bool operator < (const TSIService_cancelOperation_args & ) const;

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

};


class TSIService_cancelOperation_pargs {
 public:


  virtual ~TSIService_cancelOperation_pargs() noexcept;
  const TSCancelOperationReq* req;

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

};

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

class TSIService_cancelOperation_result {
 public:

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

  virtual ~TSIService_cancelOperation_result() noexcept;
  TSStatus success;

  _TSIService_cancelOperation_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_cancelOperation_result & ) const;

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

};

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

class TSIService_cancelOperation_presult {
 public:


  virtual ~TSIService_cancelOperation_presult() noexcept;
  TSStatus* success;

  _TSIService_cancelOperation_presult__isset __isset;

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

};

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

class TSIService_closeOperation_args {
 public:

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

  virtual ~TSIService_closeOperation_args() noexcept;
  TSCloseOperationReq req;

  _TSIService_closeOperation_args__isset __isset;

  void __set_req(const TSCloseOperationReq& val);

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

  bool operator < (const TSIService_closeOperation_args & ) const;

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

};


class TSIService_closeOperation_pargs {
 public:


  virtual ~TSIService_closeOperation_pargs() noexcept;
  const TSCloseOperationReq* req;

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

};

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

class TSIService_closeOperation_result {
 public:

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

  virtual ~TSIService_closeOperation_result() noexcept;
  TSStatus success;

  _TSIService_closeOperation_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_closeOperation_result & ) const;

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

};

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

class TSIService_closeOperation_presult {
 public:


  virtual ~TSIService_closeOperation_presult() noexcept;
  TSStatus* success;

  _TSIService_closeOperation_presult__isset __isset;

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

};

typedef struct _TSIService_getTimeZone_args__isset {
  _TSIService_getTimeZone_args__isset() : sessionId(false) {}
  bool sessionId :1;
} _TSIService_getTimeZone_args__isset;

class TSIService_getTimeZone_args {
 public:

  TSIService_getTimeZone_args(const TSIService_getTimeZone_args&);
  TSIService_getTimeZone_args& operator=(const TSIService_getTimeZone_args&);
  TSIService_getTimeZone_args() : sessionId(0) {
  }

  virtual ~TSIService_getTimeZone_args() noexcept;
  int64_t sessionId;

  _TSIService_getTimeZone_args__isset __isset;

  void __set_sessionId(const int64_t val);

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

  bool operator < (const TSIService_getTimeZone_args & ) const;

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

};


class TSIService_getTimeZone_pargs {
 public:


  virtual ~TSIService_getTimeZone_pargs() noexcept;
  const int64_t* sessionId;

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

};

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

class TSIService_getTimeZone_result {
 public:

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

  virtual ~TSIService_getTimeZone_result() noexcept;
  TSGetTimeZoneResp success;

  _TSIService_getTimeZone_result__isset __isset;

  void __set_success(const TSGetTimeZoneResp& val);

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

  bool operator < (const TSIService_getTimeZone_result & ) const;

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

};

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

class TSIService_getTimeZone_presult {
 public:


  virtual ~TSIService_getTimeZone_presult() noexcept;
  TSGetTimeZoneResp* success;

  _TSIService_getTimeZone_presult__isset __isset;

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

};

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

class TSIService_setTimeZone_args {
 public:

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

  virtual ~TSIService_setTimeZone_args() noexcept;
  TSSetTimeZoneReq req;

  _TSIService_setTimeZone_args__isset __isset;

  void __set_req(const TSSetTimeZoneReq& val);

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

  bool operator < (const TSIService_setTimeZone_args & ) const;

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

};


class TSIService_setTimeZone_pargs {
 public:


  virtual ~TSIService_setTimeZone_pargs() noexcept;
  const TSSetTimeZoneReq* req;

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

};

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

class TSIService_setTimeZone_result {
 public:

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

  virtual ~TSIService_setTimeZone_result() noexcept;
  TSStatus success;

  _TSIService_setTimeZone_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_setTimeZone_result & ) const;

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

};

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

class TSIService_setTimeZone_presult {
 public:


  virtual ~TSIService_setTimeZone_presult() noexcept;
  TSStatus* success;

  _TSIService_setTimeZone_presult__isset __isset;

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

};


class TSIService_getProperties_args {
 public:

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

  virtual ~TSIService_getProperties_args() noexcept;

  bool operator == (const TSIService_getProperties_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const TSIService_getProperties_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSIService_getProperties_args & ) const;

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

};


class TSIService_getProperties_pargs {
 public:


  virtual ~TSIService_getProperties_pargs() noexcept;

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

};

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

class TSIService_getProperties_result {
 public:

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

  virtual ~TSIService_getProperties_result() noexcept;
  ServerProperties success;

  _TSIService_getProperties_result__isset __isset;

  void __set_success(const ServerProperties& val);

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

  bool operator < (const TSIService_getProperties_result & ) const;

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

};

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

class TSIService_getProperties_presult {
 public:


  virtual ~TSIService_getProperties_presult() noexcept;
  ServerProperties* success;

  _TSIService_getProperties_presult__isset __isset;

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

};

typedef struct _TSIService_setStorageGroup_args__isset {
  _TSIService_setStorageGroup_args__isset() : sessionId(false), storageGroup(false) {}
  bool sessionId :1;
  bool storageGroup :1;
} _TSIService_setStorageGroup_args__isset;

class TSIService_setStorageGroup_args {
 public:

  TSIService_setStorageGroup_args(const TSIService_setStorageGroup_args&);
  TSIService_setStorageGroup_args& operator=(const TSIService_setStorageGroup_args&);
  TSIService_setStorageGroup_args() : sessionId(0), storageGroup() {
  }

  virtual ~TSIService_setStorageGroup_args() noexcept;
  int64_t sessionId;
  std::string storageGroup;

  _TSIService_setStorageGroup_args__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_storageGroup(const std::string& val);

  bool operator == (const TSIService_setStorageGroup_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(storageGroup == rhs.storageGroup))
      return false;
    return true;
  }
  bool operator != (const TSIService_setStorageGroup_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSIService_setStorageGroup_args & ) const;

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

};


class TSIService_setStorageGroup_pargs {
 public:


  virtual ~TSIService_setStorageGroup_pargs() noexcept;
  const int64_t* sessionId;
  const std::string* storageGroup;

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

};

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

class TSIService_setStorageGroup_result {
 public:

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

  virtual ~TSIService_setStorageGroup_result() noexcept;
  TSStatus success;

  _TSIService_setStorageGroup_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_setStorageGroup_result & ) const;

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

};

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

class TSIService_setStorageGroup_presult {
 public:


  virtual ~TSIService_setStorageGroup_presult() noexcept;
  TSStatus* success;

  _TSIService_setStorageGroup_presult__isset __isset;

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

};

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

class TSIService_createTimeseries_args {
 public:

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

  virtual ~TSIService_createTimeseries_args() noexcept;
  TSCreateTimeseriesReq req;

  _TSIService_createTimeseries_args__isset __isset;

  void __set_req(const TSCreateTimeseriesReq& val);

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

  bool operator < (const TSIService_createTimeseries_args & ) const;

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

};


class TSIService_createTimeseries_pargs {
 public:


  virtual ~TSIService_createTimeseries_pargs() noexcept;
  const TSCreateTimeseriesReq* req;

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

};

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

class TSIService_createTimeseries_result {
 public:

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

  virtual ~TSIService_createTimeseries_result() noexcept;
  TSStatus success;

  _TSIService_createTimeseries_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_createTimeseries_result & ) const;

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

};

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

class TSIService_createTimeseries_presult {
 public:


  virtual ~TSIService_createTimeseries_presult() noexcept;
  TSStatus* success;

  _TSIService_createTimeseries_presult__isset __isset;

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

};

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

class TSIService_createMultiTimeseries_args {
 public:

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

  virtual ~TSIService_createMultiTimeseries_args() noexcept;
  TSCreateMultiTimeseriesReq req;

  _TSIService_createMultiTimeseries_args__isset __isset;

  void __set_req(const TSCreateMultiTimeseriesReq& val);

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

  bool operator < (const TSIService_createMultiTimeseries_args & ) const;

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

};


class TSIService_createMultiTimeseries_pargs {
 public:


  virtual ~TSIService_createMultiTimeseries_pargs() noexcept;
  const TSCreateMultiTimeseriesReq* req;

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

};

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

class TSIService_createMultiTimeseries_result {
 public:

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

  virtual ~TSIService_createMultiTimeseries_result() noexcept;
  TSStatus success;

  _TSIService_createMultiTimeseries_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_createMultiTimeseries_result & ) const;

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

};

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

class TSIService_createMultiTimeseries_presult {
 public:


  virtual ~TSIService_createMultiTimeseries_presult() noexcept;
  TSStatus* success;

  _TSIService_createMultiTimeseries_presult__isset __isset;

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

};

typedef struct _TSIService_deleteTimeseries_args__isset {
  _TSIService_deleteTimeseries_args__isset() : sessionId(false), path(false) {}
  bool sessionId :1;
  bool path :1;
} _TSIService_deleteTimeseries_args__isset;

class TSIService_deleteTimeseries_args {
 public:

  TSIService_deleteTimeseries_args(const TSIService_deleteTimeseries_args&);
  TSIService_deleteTimeseries_args& operator=(const TSIService_deleteTimeseries_args&);
  TSIService_deleteTimeseries_args() : sessionId(0) {
  }

  virtual ~TSIService_deleteTimeseries_args() noexcept;
  int64_t sessionId;
  std::vector<std::string>  path;

  _TSIService_deleteTimeseries_args__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_path(const std::vector<std::string> & val);

  bool operator == (const TSIService_deleteTimeseries_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(path == rhs.path))
      return false;
    return true;
  }
  bool operator != (const TSIService_deleteTimeseries_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSIService_deleteTimeseries_args & ) const;

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

};


class TSIService_deleteTimeseries_pargs {
 public:


  virtual ~TSIService_deleteTimeseries_pargs() noexcept;
  const int64_t* sessionId;
  const std::vector<std::string> * path;

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

};

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

class TSIService_deleteTimeseries_result {
 public:

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

  virtual ~TSIService_deleteTimeseries_result() noexcept;
  TSStatus success;

  _TSIService_deleteTimeseries_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_deleteTimeseries_result & ) const;

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

};

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

class TSIService_deleteTimeseries_presult {
 public:


  virtual ~TSIService_deleteTimeseries_presult() noexcept;
  TSStatus* success;

  _TSIService_deleteTimeseries_presult__isset __isset;

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

};

typedef struct _TSIService_deleteStorageGroups_args__isset {
  _TSIService_deleteStorageGroups_args__isset() : sessionId(false), storageGroup(false) {}
  bool sessionId :1;
  bool storageGroup :1;
} _TSIService_deleteStorageGroups_args__isset;

class TSIService_deleteStorageGroups_args {
 public:

  TSIService_deleteStorageGroups_args(const TSIService_deleteStorageGroups_args&);
  TSIService_deleteStorageGroups_args& operator=(const TSIService_deleteStorageGroups_args&);
  TSIService_deleteStorageGroups_args() : sessionId(0) {
  }

  virtual ~TSIService_deleteStorageGroups_args() noexcept;
  int64_t sessionId;
  std::vector<std::string>  storageGroup;

  _TSIService_deleteStorageGroups_args__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_storageGroup(const std::vector<std::string> & val);

  bool operator == (const TSIService_deleteStorageGroups_args & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(storageGroup == rhs.storageGroup))
      return false;
    return true;
  }
  bool operator != (const TSIService_deleteStorageGroups_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSIService_deleteStorageGroups_args & ) const;

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

};


class TSIService_deleteStorageGroups_pargs {
 public:


  virtual ~TSIService_deleteStorageGroups_pargs() noexcept;
  const int64_t* sessionId;
  const std::vector<std::string> * storageGroup;

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

};

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

class TSIService_deleteStorageGroups_result {
 public:

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

  virtual ~TSIService_deleteStorageGroups_result() noexcept;
  TSStatus success;

  _TSIService_deleteStorageGroups_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_deleteStorageGroups_result & ) const;

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

};

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

class TSIService_deleteStorageGroups_presult {
 public:


  virtual ~TSIService_deleteStorageGroups_presult() noexcept;
  TSStatus* success;

  _TSIService_deleteStorageGroups_presult__isset __isset;

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

};

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

class TSIService_insertRecord_args {
 public:

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

  virtual ~TSIService_insertRecord_args() noexcept;
  TSInsertRecordReq req;

  _TSIService_insertRecord_args__isset __isset;

  void __set_req(const TSInsertRecordReq& val);

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

  bool operator < (const TSIService_insertRecord_args & ) const;

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

};


class TSIService_insertRecord_pargs {
 public:


  virtual ~TSIService_insertRecord_pargs() noexcept;
  const TSInsertRecordReq* req;

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

};

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

class TSIService_insertRecord_result {
 public:

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

  virtual ~TSIService_insertRecord_result() noexcept;
  TSStatus success;

  _TSIService_insertRecord_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_insertRecord_result & ) const;

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

};

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

class TSIService_insertRecord_presult {
 public:


  virtual ~TSIService_insertRecord_presult() noexcept;
  TSStatus* success;

  _TSIService_insertRecord_presult__isset __isset;

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

};

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

class TSIService_insertStringRecord_args {
 public:

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

  virtual ~TSIService_insertStringRecord_args() noexcept;
  TSInsertStringRecordReq req;

  _TSIService_insertStringRecord_args__isset __isset;

  void __set_req(const TSInsertStringRecordReq& val);

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

  bool operator < (const TSIService_insertStringRecord_args & ) const;

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

};


class TSIService_insertStringRecord_pargs {
 public:


  virtual ~TSIService_insertStringRecord_pargs() noexcept;
  const TSInsertStringRecordReq* req;

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

};

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

class TSIService_insertStringRecord_result {
 public:

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

  virtual ~TSIService_insertStringRecord_result() noexcept;
  TSStatus success;

  _TSIService_insertStringRecord_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_insertStringRecord_result & ) const;

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

};

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

class TSIService_insertStringRecord_presult {
 public:


  virtual ~TSIService_insertStringRecord_presult() noexcept;
  TSStatus* success;

  _TSIService_insertStringRecord_presult__isset __isset;

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

};

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

class TSIService_insertTablet_args {
 public:

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

  virtual ~TSIService_insertTablet_args() noexcept;
  TSInsertTabletReq req;

  _TSIService_insertTablet_args__isset __isset;

  void __set_req(const TSInsertTabletReq& val);

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

  bool operator < (const TSIService_insertTablet_args & ) const;

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

};


class TSIService_insertTablet_pargs {
 public:


  virtual ~TSIService_insertTablet_pargs() noexcept;
  const TSInsertTabletReq* req;

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

};

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

class TSIService_insertTablet_result {
 public:

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

  virtual ~TSIService_insertTablet_result() noexcept;
  TSStatus success;

  _TSIService_insertTablet_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_insertTablet_result & ) const;

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

};

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

class TSIService_insertTablet_presult {
 public:


  virtual ~TSIService_insertTablet_presult() noexcept;
  TSStatus* success;

  _TSIService_insertTablet_presult__isset __isset;

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

};

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

class TSIService_insertTablets_args {
 public:

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

  virtual ~TSIService_insertTablets_args() noexcept;
  TSInsertTabletsReq req;

  _TSIService_insertTablets_args__isset __isset;

  void __set_req(const TSInsertTabletsReq& val);

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

  bool operator < (const TSIService_insertTablets_args & ) const;

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

};


class TSIService_insertTablets_pargs {
 public:


  virtual ~TSIService_insertTablets_pargs() noexcept;
  const TSInsertTabletsReq* req;

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

};

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

class TSIService_insertTablets_result {
 public:

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

  virtual ~TSIService_insertTablets_result() noexcept;
  TSStatus success;

  _TSIService_insertTablets_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_insertTablets_result & ) const;

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

};

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

class TSIService_insertTablets_presult {
 public:


  virtual ~TSIService_insertTablets_presult() noexcept;
  TSStatus* success;

  _TSIService_insertTablets_presult__isset __isset;

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

};

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

class TSIService_insertRecords_args {
 public:

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

  virtual ~TSIService_insertRecords_args() noexcept;
  TSInsertRecordsReq req;

  _TSIService_insertRecords_args__isset __isset;

  void __set_req(const TSInsertRecordsReq& val);

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

  bool operator < (const TSIService_insertRecords_args & ) const;

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

};


class TSIService_insertRecords_pargs {
 public:


  virtual ~TSIService_insertRecords_pargs() noexcept;
  const TSInsertRecordsReq* req;

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

};

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

class TSIService_insertRecords_result {
 public:

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

  virtual ~TSIService_insertRecords_result() noexcept;
  TSStatus success;

  _TSIService_insertRecords_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_insertRecords_result & ) const;

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

};

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

class TSIService_insertRecords_presult {
 public:


  virtual ~TSIService_insertRecords_presult() noexcept;
  TSStatus* success;

  _TSIService_insertRecords_presult__isset __isset;

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

};

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

class TSIService_insertRecordsOfOneDevice_args {
 public:

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

  virtual ~TSIService_insertRecordsOfOneDevice_args() noexcept;
  TSInsertRecordsOfOneDeviceReq req;

  _TSIService_insertRecordsOfOneDevice_args__isset __isset;

  void __set_req(const TSInsertRecordsOfOneDeviceReq& val);

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

  bool operator < (const TSIService_insertRecordsOfOneDevice_args & ) const;

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

};


class TSIService_insertRecordsOfOneDevice_pargs {
 public:


  virtual ~TSIService_insertRecordsOfOneDevice_pargs() noexcept;
  const TSInsertRecordsOfOneDeviceReq* req;

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

};

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

class TSIService_insertRecordsOfOneDevice_result {
 public:

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

  virtual ~TSIService_insertRecordsOfOneDevice_result() noexcept;
  TSStatus success;

  _TSIService_insertRecordsOfOneDevice_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_insertRecordsOfOneDevice_result & ) const;

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

};

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

class TSIService_insertRecordsOfOneDevice_presult {
 public:


  virtual ~TSIService_insertRecordsOfOneDevice_presult() noexcept;
  TSStatus* success;

  _TSIService_insertRecordsOfOneDevice_presult__isset __isset;

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

};

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

class TSIService_insertStringRecords_args {
 public:

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

  virtual ~TSIService_insertStringRecords_args() noexcept;
  TSInsertStringRecordsReq req;

  _TSIService_insertStringRecords_args__isset __isset;

  void __set_req(const TSInsertStringRecordsReq& val);

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

  bool operator < (const TSIService_insertStringRecords_args & ) const;

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

};


class TSIService_insertStringRecords_pargs {
 public:


  virtual ~TSIService_insertStringRecords_pargs() noexcept;
  const TSInsertStringRecordsReq* req;

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

};

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

class TSIService_insertStringRecords_result {
 public:

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

  virtual ~TSIService_insertStringRecords_result() noexcept;
  TSStatus success;

  _TSIService_insertStringRecords_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_insertStringRecords_result & ) const;

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

};

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

class TSIService_insertStringRecords_presult {
 public:


  virtual ~TSIService_insertStringRecords_presult() noexcept;
  TSStatus* success;

  _TSIService_insertStringRecords_presult__isset __isset;

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

};

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

class TSIService_testInsertTablet_args {
 public:

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

  virtual ~TSIService_testInsertTablet_args() noexcept;
  TSInsertTabletReq req;

  _TSIService_testInsertTablet_args__isset __isset;

  void __set_req(const TSInsertTabletReq& val);

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

  bool operator < (const TSIService_testInsertTablet_args & ) const;

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

};


class TSIService_testInsertTablet_pargs {
 public:


  virtual ~TSIService_testInsertTablet_pargs() noexcept;
  const TSInsertTabletReq* req;

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

};

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

class TSIService_testInsertTablet_result {
 public:

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

  virtual ~TSIService_testInsertTablet_result() noexcept;
  TSStatus success;

  _TSIService_testInsertTablet_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_testInsertTablet_result & ) const;

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

};

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

class TSIService_testInsertTablet_presult {
 public:


  virtual ~TSIService_testInsertTablet_presult() noexcept;
  TSStatus* success;

  _TSIService_testInsertTablet_presult__isset __isset;

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

};

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

class TSIService_testInsertTablets_args {
 public:

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

  virtual ~TSIService_testInsertTablets_args() noexcept;
  TSInsertTabletsReq req;

  _TSIService_testInsertTablets_args__isset __isset;

  void __set_req(const TSInsertTabletsReq& val);

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

  bool operator < (const TSIService_testInsertTablets_args & ) const;

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

};


class TSIService_testInsertTablets_pargs {
 public:


  virtual ~TSIService_testInsertTablets_pargs() noexcept;
  const TSInsertTabletsReq* req;

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

};

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

class TSIService_testInsertTablets_result {
 public:

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

  virtual ~TSIService_testInsertTablets_result() noexcept;
  TSStatus success;

  _TSIService_testInsertTablets_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_testInsertTablets_result & ) const;

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

};

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

class TSIService_testInsertTablets_presult {
 public:


  virtual ~TSIService_testInsertTablets_presult() noexcept;
  TSStatus* success;

  _TSIService_testInsertTablets_presult__isset __isset;

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

};

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

class TSIService_testInsertRecord_args {
 public:

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

  virtual ~TSIService_testInsertRecord_args() noexcept;
  TSInsertRecordReq req;

  _TSIService_testInsertRecord_args__isset __isset;

  void __set_req(const TSInsertRecordReq& val);

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

  bool operator < (const TSIService_testInsertRecord_args & ) const;

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

};


class TSIService_testInsertRecord_pargs {
 public:


  virtual ~TSIService_testInsertRecord_pargs() noexcept;
  const TSInsertRecordReq* req;

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

};

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

class TSIService_testInsertRecord_result {
 public:

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

  virtual ~TSIService_testInsertRecord_result() noexcept;
  TSStatus success;

  _TSIService_testInsertRecord_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_testInsertRecord_result & ) const;

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

};

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

class TSIService_testInsertRecord_presult {
 public:


  virtual ~TSIService_testInsertRecord_presult() noexcept;
  TSStatus* success;

  _TSIService_testInsertRecord_presult__isset __isset;

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

};

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

class TSIService_testInsertStringRecord_args {
 public:

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

  virtual ~TSIService_testInsertStringRecord_args() noexcept;
  TSInsertStringRecordReq req;

  _TSIService_testInsertStringRecord_args__isset __isset;

  void __set_req(const TSInsertStringRecordReq& val);

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

  bool operator < (const TSIService_testInsertStringRecord_args & ) const;

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

};


class TSIService_testInsertStringRecord_pargs {
 public:


  virtual ~TSIService_testInsertStringRecord_pargs() noexcept;
  const TSInsertStringRecordReq* req;

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

};

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

class TSIService_testInsertStringRecord_result {
 public:

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

  virtual ~TSIService_testInsertStringRecord_result() noexcept;
  TSStatus success;

  _TSIService_testInsertStringRecord_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_testInsertStringRecord_result & ) const;

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

};

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

class TSIService_testInsertStringRecord_presult {
 public:


  virtual ~TSIService_testInsertStringRecord_presult() noexcept;
  TSStatus* success;

  _TSIService_testInsertStringRecord_presult__isset __isset;

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

};

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

class TSIService_testInsertRecords_args {
 public:

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

  virtual ~TSIService_testInsertRecords_args() noexcept;
  TSInsertRecordsReq req;

  _TSIService_testInsertRecords_args__isset __isset;

  void __set_req(const TSInsertRecordsReq& val);

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

  bool operator < (const TSIService_testInsertRecords_args & ) const;

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

};


class TSIService_testInsertRecords_pargs {
 public:


  virtual ~TSIService_testInsertRecords_pargs() noexcept;
  const TSInsertRecordsReq* req;

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

};

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

class TSIService_testInsertRecords_result {
 public:

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

  virtual ~TSIService_testInsertRecords_result() noexcept;
  TSStatus success;

  _TSIService_testInsertRecords_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_testInsertRecords_result & ) const;

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

};

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

class TSIService_testInsertRecords_presult {
 public:


  virtual ~TSIService_testInsertRecords_presult() noexcept;
  TSStatus* success;

  _TSIService_testInsertRecords_presult__isset __isset;

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

};

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

class TSIService_testInsertRecordsOfOneDevice_args {
 public:

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

  virtual ~TSIService_testInsertRecordsOfOneDevice_args() noexcept;
  TSInsertRecordsOfOneDeviceReq req;

  _TSIService_testInsertRecordsOfOneDevice_args__isset __isset;

  void __set_req(const TSInsertRecordsOfOneDeviceReq& val);

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

  bool operator < (const TSIService_testInsertRecordsOfOneDevice_args & ) const;

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

};


class TSIService_testInsertRecordsOfOneDevice_pargs {
 public:


  virtual ~TSIService_testInsertRecordsOfOneDevice_pargs() noexcept;
  const TSInsertRecordsOfOneDeviceReq* req;

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

};

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

class TSIService_testInsertRecordsOfOneDevice_result {
 public:

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

  virtual ~TSIService_testInsertRecordsOfOneDevice_result() noexcept;
  TSStatus success;

  _TSIService_testInsertRecordsOfOneDevice_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_testInsertRecordsOfOneDevice_result & ) const;

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

};

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

class TSIService_testInsertRecordsOfOneDevice_presult {
 public:


  virtual ~TSIService_testInsertRecordsOfOneDevice_presult() noexcept;
  TSStatus* success;

  _TSIService_testInsertRecordsOfOneDevice_presult__isset __isset;

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

};

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

class TSIService_testInsertStringRecords_args {
 public:

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

  virtual ~TSIService_testInsertStringRecords_args() noexcept;
  TSInsertStringRecordsReq req;

  _TSIService_testInsertStringRecords_args__isset __isset;

  void __set_req(const TSInsertStringRecordsReq& val);

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

  bool operator < (const TSIService_testInsertStringRecords_args & ) const;

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

};


class TSIService_testInsertStringRecords_pargs {
 public:


  virtual ~TSIService_testInsertStringRecords_pargs() noexcept;
  const TSInsertStringRecordsReq* req;

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

};

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

class TSIService_testInsertStringRecords_result {
 public:

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

  virtual ~TSIService_testInsertStringRecords_result() noexcept;
  TSStatus success;

  _TSIService_testInsertStringRecords_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_testInsertStringRecords_result & ) const;

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

};

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

class TSIService_testInsertStringRecords_presult {
 public:


  virtual ~TSIService_testInsertStringRecords_presult() noexcept;
  TSStatus* success;

  _TSIService_testInsertStringRecords_presult__isset __isset;

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

};

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

class TSIService_deleteData_args {
 public:

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

  virtual ~TSIService_deleteData_args() noexcept;
  TSDeleteDataReq req;

  _TSIService_deleteData_args__isset __isset;

  void __set_req(const TSDeleteDataReq& val);

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

  bool operator < (const TSIService_deleteData_args & ) const;

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

};


class TSIService_deleteData_pargs {
 public:


  virtual ~TSIService_deleteData_pargs() noexcept;
  const TSDeleteDataReq* req;

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

};

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

class TSIService_deleteData_result {
 public:

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

  virtual ~TSIService_deleteData_result() noexcept;
  TSStatus success;

  _TSIService_deleteData_result__isset __isset;

  void __set_success(const TSStatus& val);

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

  bool operator < (const TSIService_deleteData_result & ) const;

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

};

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

class TSIService_deleteData_presult {
 public:


  virtual ~TSIService_deleteData_presult() noexcept;
  TSStatus* success;

  _TSIService_deleteData_presult__isset __isset;

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

};

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

class TSIService_executeRawDataQuery_args {
 public:

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

  virtual ~TSIService_executeRawDataQuery_args() noexcept;
  TSRawDataQueryReq req;

  _TSIService_executeRawDataQuery_args__isset __isset;

  void __set_req(const TSRawDataQueryReq& val);

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

  bool operator < (const TSIService_executeRawDataQuery_args & ) const;

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

};


class TSIService_executeRawDataQuery_pargs {
 public:


  virtual ~TSIService_executeRawDataQuery_pargs() noexcept;
  const TSRawDataQueryReq* req;

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

};

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

class TSIService_executeRawDataQuery_result {
 public:

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

  virtual ~TSIService_executeRawDataQuery_result() noexcept;
  TSExecuteStatementResp success;

  _TSIService_executeRawDataQuery_result__isset __isset;

  void __set_success(const TSExecuteStatementResp& val);

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

  bool operator < (const TSIService_executeRawDataQuery_result & ) const;

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

};

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

class TSIService_executeRawDataQuery_presult {
 public:


  virtual ~TSIService_executeRawDataQuery_presult() noexcept;
  TSExecuteStatementResp* success;

  _TSIService_executeRawDataQuery_presult__isset __isset;

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

};

typedef struct _TSIService_requestStatementId_args__isset {
  _TSIService_requestStatementId_args__isset() : sessionId(false) {}
  bool sessionId :1;
} _TSIService_requestStatementId_args__isset;

class TSIService_requestStatementId_args {
 public:

  TSIService_requestStatementId_args(const TSIService_requestStatementId_args&);
  TSIService_requestStatementId_args& operator=(const TSIService_requestStatementId_args&);
  TSIService_requestStatementId_args() : sessionId(0) {
  }

  virtual ~TSIService_requestStatementId_args() noexcept;
  int64_t sessionId;

  _TSIService_requestStatementId_args__isset __isset;

  void __set_sessionId(const int64_t val);

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

  bool operator < (const TSIService_requestStatementId_args & ) const;

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

};


class TSIService_requestStatementId_pargs {
 public:


  virtual ~TSIService_requestStatementId_pargs() noexcept;
  const int64_t* sessionId;

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

};

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

class TSIService_requestStatementId_result {
 public:

  TSIService_requestStatementId_result(const TSIService_requestStatementId_result&);
  TSIService_requestStatementId_result& operator=(const TSIService_requestStatementId_result&);
  TSIService_requestStatementId_result() : success(0) {
  }

  virtual ~TSIService_requestStatementId_result() noexcept;
  int64_t success;

  _TSIService_requestStatementId_result__isset __isset;

  void __set_success(const int64_t val);

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

  bool operator < (const TSIService_requestStatementId_result & ) const;

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

};

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

class TSIService_requestStatementId_presult {
 public:


  virtual ~TSIService_requestStatementId_presult() noexcept;
  int64_t* success;

  _TSIService_requestStatementId_presult__isset __isset;

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

};

class TSIServiceClient : virtual public TSIServiceIf {
 public:
  TSIServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  TSIServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& req);
  void send_openSession(const TSOpenSessionReq& req);
  void recv_openSession(TSOpenSessionResp& _return);
  void closeSession(TSStatus& _return, const TSCloseSessionReq& req);
  void send_closeSession(const TSCloseSessionReq& req);
  void recv_closeSession(TSStatus& _return);
  void executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeStatement(const TSExecuteStatementReq& req);
  void recv_executeStatement(TSExecuteStatementResp& _return);
  void executeBatchStatement(TSStatus& _return, const TSExecuteBatchStatementReq& req);
  void send_executeBatchStatement(const TSExecuteBatchStatementReq& req);
  void recv_executeBatchStatement(TSStatus& _return);
  void executeQueryStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeQueryStatement(const TSExecuteStatementReq& req);
  void recv_executeQueryStatement(TSExecuteStatementResp& _return);
  void executeUpdateStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  void send_executeUpdateStatement(const TSExecuteStatementReq& req);
  void recv_executeUpdateStatement(TSExecuteStatementResp& _return);
  void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& req);
  void send_fetchResults(const TSFetchResultsReq& req);
  void recv_fetchResults(TSFetchResultsResp& _return);
  void fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req);
  void send_fetchMetadata(const TSFetchMetadataReq& req);
  void recv_fetchMetadata(TSFetchMetadataResp& _return);
  void cancelOperation(TSStatus& _return, const TSCancelOperationReq& req);
  void send_cancelOperation(const TSCancelOperationReq& req);
  void recv_cancelOperation(TSStatus& _return);
  void closeOperation(TSStatus& _return, const TSCloseOperationReq& req);
  void send_closeOperation(const TSCloseOperationReq& req);
  void recv_closeOperation(TSStatus& _return);
  void getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId);
  void send_getTimeZone(const int64_t sessionId);
  void recv_getTimeZone(TSGetTimeZoneResp& _return);
  void setTimeZone(TSStatus& _return, const TSSetTimeZoneReq& req);
  void send_setTimeZone(const TSSetTimeZoneReq& req);
  void recv_setTimeZone(TSStatus& _return);
  void getProperties(ServerProperties& _return);
  void send_getProperties();
  void recv_getProperties(ServerProperties& _return);
  void setStorageGroup(TSStatus& _return, const int64_t sessionId, const std::string& storageGroup);
  void send_setStorageGroup(const int64_t sessionId, const std::string& storageGroup);
  void recv_setStorageGroup(TSStatus& _return);
  void createTimeseries(TSStatus& _return, const TSCreateTimeseriesReq& req);
  void send_createTimeseries(const TSCreateTimeseriesReq& req);
  void recv_createTimeseries(TSStatus& _return);
  void createMultiTimeseries(TSStatus& _return, const TSCreateMultiTimeseriesReq& req);
  void send_createMultiTimeseries(const TSCreateMultiTimeseriesReq& req);
  void recv_createMultiTimeseries(TSStatus& _return);
  void deleteTimeseries(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path);
  void send_deleteTimeseries(const int64_t sessionId, const std::vector<std::string> & path);
  void recv_deleteTimeseries(TSStatus& _return);
  void deleteStorageGroups(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup);
  void send_deleteStorageGroups(const int64_t sessionId, const std::vector<std::string> & storageGroup);
  void recv_deleteStorageGroups(TSStatus& _return);
  void insertRecord(TSStatus& _return, const TSInsertRecordReq& req);
  void send_insertRecord(const TSInsertRecordReq& req);
  void recv_insertRecord(TSStatus& _return);
  void insertStringRecord(TSStatus& _return, const TSInsertStringRecordReq& req);
  void send_insertStringRecord(const TSInsertStringRecordReq& req);
  void recv_insertStringRecord(TSStatus& _return);
  void insertTablet(TSStatus& _return, const TSInsertTabletReq& req);
  void send_insertTablet(const TSInsertTabletReq& req);
  void recv_insertTablet(TSStatus& _return);
  void insertTablets(TSStatus& _return, const TSInsertTabletsReq& req);
  void send_insertTablets(const TSInsertTabletsReq& req);
  void recv_insertTablets(TSStatus& _return);
  void insertRecords(TSStatus& _return, const TSInsertRecordsReq& req);
  void send_insertRecords(const TSInsertRecordsReq& req);
  void recv_insertRecords(TSStatus& _return);
  void insertRecordsOfOneDevice(TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  void send_insertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_insertRecordsOfOneDevice(TSStatus& _return);
  void insertStringRecords(TSStatus& _return, const TSInsertStringRecordsReq& req);
  void send_insertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_insertStringRecords(TSStatus& _return);
  void testInsertTablet(TSStatus& _return, const TSInsertTabletReq& req);
  void send_testInsertTablet(const TSInsertTabletReq& req);
  void recv_testInsertTablet(TSStatus& _return);
  void testInsertTablets(TSStatus& _return, const TSInsertTabletsReq& req);
  void send_testInsertTablets(const TSInsertTabletsReq& req);
  void recv_testInsertTablets(TSStatus& _return);
  void testInsertRecord(TSStatus& _return, const TSInsertRecordReq& req);
  void send_testInsertRecord(const TSInsertRecordReq& req);
  void recv_testInsertRecord(TSStatus& _return);
  void testInsertStringRecord(TSStatus& _return, const TSInsertStringRecordReq& req);
  void send_testInsertStringRecord(const TSInsertStringRecordReq& req);
  void recv_testInsertStringRecord(TSStatus& _return);
  void testInsertRecords(TSStatus& _return, const TSInsertRecordsReq& req);
  void send_testInsertRecords(const TSInsertRecordsReq& req);
  void recv_testInsertRecords(TSStatus& _return);
  void testInsertRecordsOfOneDevice(TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  void send_testInsertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_testInsertRecordsOfOneDevice(TSStatus& _return);
  void testInsertStringRecords(TSStatus& _return, const TSInsertStringRecordsReq& req);
  void send_testInsertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_testInsertStringRecords(TSStatus& _return);
  void deleteData(TSStatus& _return, const TSDeleteDataReq& req);
  void send_deleteData(const TSDeleteDataReq& req);
  void recv_deleteData(TSStatus& _return);
  void executeRawDataQuery(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req);
  void send_executeRawDataQuery(const TSRawDataQueryReq& req);
  void recv_executeRawDataQuery(TSExecuteStatementResp& _return);
  int64_t requestStatementId(const int64_t sessionId);
  void send_requestStatementId(const int64_t sessionId);
  int64_t recv_requestStatementId();
 protected:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class TSIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  ::std::shared_ptr<TSIServiceIf> 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 (TSIServiceProcessor::*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_executeStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeBatchStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeQueryStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeUpdateStatement(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_fetchMetadata(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_getTimeZone(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_setTimeZone(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getProperties(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_setStorageGroup(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_createTimeseries(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_createMultiTimeseries(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteTimeseries(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteStorageGroups(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertStringRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertTablet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertTablets(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertRecordsOfOneDevice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_insertStringRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertTablet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertTablets(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertStringRecord(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertRecordsOfOneDevice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_testInsertStringRecords(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteData(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_executeRawDataQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_requestStatementId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  TSIServiceProcessor(::std::shared_ptr<TSIServiceIf> iface) :
    iface_(iface) {
    processMap_["openSession"] = &TSIServiceProcessor::process_openSession;
    processMap_["closeSession"] = &TSIServiceProcessor::process_closeSession;
    processMap_["executeStatement"] = &TSIServiceProcessor::process_executeStatement;
    processMap_["executeBatchStatement"] = &TSIServiceProcessor::process_executeBatchStatement;
    processMap_["executeQueryStatement"] = &TSIServiceProcessor::process_executeQueryStatement;
    processMap_["executeUpdateStatement"] = &TSIServiceProcessor::process_executeUpdateStatement;
    processMap_["fetchResults"] = &TSIServiceProcessor::process_fetchResults;
    processMap_["fetchMetadata"] = &TSIServiceProcessor::process_fetchMetadata;
    processMap_["cancelOperation"] = &TSIServiceProcessor::process_cancelOperation;
    processMap_["closeOperation"] = &TSIServiceProcessor::process_closeOperation;
    processMap_["getTimeZone"] = &TSIServiceProcessor::process_getTimeZone;
    processMap_["setTimeZone"] = &TSIServiceProcessor::process_setTimeZone;
    processMap_["getProperties"] = &TSIServiceProcessor::process_getProperties;
    processMap_["setStorageGroup"] = &TSIServiceProcessor::process_setStorageGroup;
    processMap_["createTimeseries"] = &TSIServiceProcessor::process_createTimeseries;
    processMap_["createMultiTimeseries"] = &TSIServiceProcessor::process_createMultiTimeseries;
    processMap_["deleteTimeseries"] = &TSIServiceProcessor::process_deleteTimeseries;
    processMap_["deleteStorageGroups"] = &TSIServiceProcessor::process_deleteStorageGroups;
    processMap_["insertRecord"] = &TSIServiceProcessor::process_insertRecord;
    processMap_["insertStringRecord"] = &TSIServiceProcessor::process_insertStringRecord;
    processMap_["insertTablet"] = &TSIServiceProcessor::process_insertTablet;
    processMap_["insertTablets"] = &TSIServiceProcessor::process_insertTablets;
    processMap_["insertRecords"] = &TSIServiceProcessor::process_insertRecords;
    processMap_["insertRecordsOfOneDevice"] = &TSIServiceProcessor::process_insertRecordsOfOneDevice;
    processMap_["insertStringRecords"] = &TSIServiceProcessor::process_insertStringRecords;
    processMap_["testInsertTablet"] = &TSIServiceProcessor::process_testInsertTablet;
    processMap_["testInsertTablets"] = &TSIServiceProcessor::process_testInsertTablets;
    processMap_["testInsertRecord"] = &TSIServiceProcessor::process_testInsertRecord;
    processMap_["testInsertStringRecord"] = &TSIServiceProcessor::process_testInsertStringRecord;
    processMap_["testInsertRecords"] = &TSIServiceProcessor::process_testInsertRecords;
    processMap_["testInsertRecordsOfOneDevice"] = &TSIServiceProcessor::process_testInsertRecordsOfOneDevice;
    processMap_["testInsertStringRecords"] = &TSIServiceProcessor::process_testInsertStringRecords;
    processMap_["deleteData"] = &TSIServiceProcessor::process_deleteData;
    processMap_["executeRawDataQuery"] = &TSIServiceProcessor::process_executeRawDataQuery;
    processMap_["requestStatementId"] = &TSIServiceProcessor::process_requestStatementId;
  }

  virtual ~TSIServiceProcessor() {}
};

class TSIServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  TSIServiceProcessorFactory(const ::std::shared_ptr< TSIServiceIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

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

 protected:
  ::std::shared_ptr< TSIServiceIfFactory > handlerFactory_;
};

class TSIServiceMultiface : virtual public TSIServiceIf {
 public:
  TSIServiceMultiface(std::vector<std::shared_ptr<TSIServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~TSIServiceMultiface() {}
 protected:
  std::vector<std::shared_ptr<TSIServiceIf> > ifaces_;
  TSIServiceMultiface() {}
  void add(::std::shared_ptr<TSIServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& 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(TSStatus& _return, const TSCloseSessionReq& 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 executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& 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 executeBatchStatement(TSStatus& _return, const TSExecuteBatchStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->executeBatchStatement(_return, req);
    }
    ifaces_[i]->executeBatchStatement(_return, req);
    return;
  }

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

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

  void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& 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 fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->fetchMetadata(_return, req);
    }
    ifaces_[i]->fetchMetadata(_return, req);
    return;
  }

  void cancelOperation(TSStatus& _return, const TSCancelOperationReq& 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(TSStatus& _return, const TSCloseOperationReq& 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 getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getTimeZone(_return, sessionId);
    }
    ifaces_[i]->getTimeZone(_return, sessionId);
    return;
  }

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

  void getProperties(ServerProperties& _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getProperties(_return);
    }
    ifaces_[i]->getProperties(_return);
    return;
  }

  void setStorageGroup(TSStatus& _return, const int64_t sessionId, const std::string& storageGroup) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->setStorageGroup(_return, sessionId, storageGroup);
    }
    ifaces_[i]->setStorageGroup(_return, sessionId, storageGroup);
    return;
  }

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

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

  void deleteTimeseries(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->deleteTimeseries(_return, sessionId, path);
    }
    ifaces_[i]->deleteTimeseries(_return, sessionId, path);
    return;
  }

  void deleteStorageGroups(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->deleteStorageGroups(_return, sessionId, storageGroup);
    }
    ifaces_[i]->deleteStorageGroups(_return, sessionId, storageGroup);
    return;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  int64_t requestStatementId(const int64_t sessionId) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->requestStatementId(sessionId);
    }
    return ifaces_[i]->requestStatementId(sessionId);
  }

};

// 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 TSIServiceConcurrentClient : virtual public TSIServiceIf {
 public:
  TSIServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocol(prot);
  }
  TSIServiceConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void openSession(TSOpenSessionResp& _return, const TSOpenSessionReq& req);
  int32_t send_openSession(const TSOpenSessionReq& req);
  void recv_openSession(TSOpenSessionResp& _return, const int32_t seqid);
  void closeSession(TSStatus& _return, const TSCloseSessionReq& req);
  int32_t send_closeSession(const TSCloseSessionReq& req);
  void recv_closeSession(TSStatus& _return, const int32_t seqid);
  void executeStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeStatement(const TSExecuteStatementReq& req);
  void recv_executeStatement(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeBatchStatement(TSStatus& _return, const TSExecuteBatchStatementReq& req);
  int32_t send_executeBatchStatement(const TSExecuteBatchStatementReq& req);
  void recv_executeBatchStatement(TSStatus& _return, const int32_t seqid);
  void executeQueryStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeQueryStatement(const TSExecuteStatementReq& req);
  void recv_executeQueryStatement(TSExecuteStatementResp& _return, const int32_t seqid);
  void executeUpdateStatement(TSExecuteStatementResp& _return, const TSExecuteStatementReq& req);
  int32_t send_executeUpdateStatement(const TSExecuteStatementReq& req);
  void recv_executeUpdateStatement(TSExecuteStatementResp& _return, const int32_t seqid);
  void fetchResults(TSFetchResultsResp& _return, const TSFetchResultsReq& req);
  int32_t send_fetchResults(const TSFetchResultsReq& req);
  void recv_fetchResults(TSFetchResultsResp& _return, const int32_t seqid);
  void fetchMetadata(TSFetchMetadataResp& _return, const TSFetchMetadataReq& req);
  int32_t send_fetchMetadata(const TSFetchMetadataReq& req);
  void recv_fetchMetadata(TSFetchMetadataResp& _return, const int32_t seqid);
  void cancelOperation(TSStatus& _return, const TSCancelOperationReq& req);
  int32_t send_cancelOperation(const TSCancelOperationReq& req);
  void recv_cancelOperation(TSStatus& _return, const int32_t seqid);
  void closeOperation(TSStatus& _return, const TSCloseOperationReq& req);
  int32_t send_closeOperation(const TSCloseOperationReq& req);
  void recv_closeOperation(TSStatus& _return, const int32_t seqid);
  void getTimeZone(TSGetTimeZoneResp& _return, const int64_t sessionId);
  int32_t send_getTimeZone(const int64_t sessionId);
  void recv_getTimeZone(TSGetTimeZoneResp& _return, const int32_t seqid);
  void setTimeZone(TSStatus& _return, const TSSetTimeZoneReq& req);
  int32_t send_setTimeZone(const TSSetTimeZoneReq& req);
  void recv_setTimeZone(TSStatus& _return, const int32_t seqid);
  void getProperties(ServerProperties& _return);
  int32_t send_getProperties();
  void recv_getProperties(ServerProperties& _return, const int32_t seqid);
  void setStorageGroup(TSStatus& _return, const int64_t sessionId, const std::string& storageGroup);
  int32_t send_setStorageGroup(const int64_t sessionId, const std::string& storageGroup);
  void recv_setStorageGroup(TSStatus& _return, const int32_t seqid);
  void createTimeseries(TSStatus& _return, const TSCreateTimeseriesReq& req);
  int32_t send_createTimeseries(const TSCreateTimeseriesReq& req);
  void recv_createTimeseries(TSStatus& _return, const int32_t seqid);
  void createMultiTimeseries(TSStatus& _return, const TSCreateMultiTimeseriesReq& req);
  int32_t send_createMultiTimeseries(const TSCreateMultiTimeseriesReq& req);
  void recv_createMultiTimeseries(TSStatus& _return, const int32_t seqid);
  void deleteTimeseries(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & path);
  int32_t send_deleteTimeseries(const int64_t sessionId, const std::vector<std::string> & path);
  void recv_deleteTimeseries(TSStatus& _return, const int32_t seqid);
  void deleteStorageGroups(TSStatus& _return, const int64_t sessionId, const std::vector<std::string> & storageGroup);
  int32_t send_deleteStorageGroups(const int64_t sessionId, const std::vector<std::string> & storageGroup);
  void recv_deleteStorageGroups(TSStatus& _return, const int32_t seqid);
  void insertRecord(TSStatus& _return, const TSInsertRecordReq& req);
  int32_t send_insertRecord(const TSInsertRecordReq& req);
  void recv_insertRecord(TSStatus& _return, const int32_t seqid);
  void insertStringRecord(TSStatus& _return, const TSInsertStringRecordReq& req);
  int32_t send_insertStringRecord(const TSInsertStringRecordReq& req);
  void recv_insertStringRecord(TSStatus& _return, const int32_t seqid);
  void insertTablet(TSStatus& _return, const TSInsertTabletReq& req);
  int32_t send_insertTablet(const TSInsertTabletReq& req);
  void recv_insertTablet(TSStatus& _return, const int32_t seqid);
  void insertTablets(TSStatus& _return, const TSInsertTabletsReq& req);
  int32_t send_insertTablets(const TSInsertTabletsReq& req);
  void recv_insertTablets(TSStatus& _return, const int32_t seqid);
  void insertRecords(TSStatus& _return, const TSInsertRecordsReq& req);
  int32_t send_insertRecords(const TSInsertRecordsReq& req);
  void recv_insertRecords(TSStatus& _return, const int32_t seqid);
  void insertRecordsOfOneDevice(TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  int32_t send_insertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_insertRecordsOfOneDevice(TSStatus& _return, const int32_t seqid);
  void insertStringRecords(TSStatus& _return, const TSInsertStringRecordsReq& req);
  int32_t send_insertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_insertStringRecords(TSStatus& _return, const int32_t seqid);
  void testInsertTablet(TSStatus& _return, const TSInsertTabletReq& req);
  int32_t send_testInsertTablet(const TSInsertTabletReq& req);
  void recv_testInsertTablet(TSStatus& _return, const int32_t seqid);
  void testInsertTablets(TSStatus& _return, const TSInsertTabletsReq& req);
  int32_t send_testInsertTablets(const TSInsertTabletsReq& req);
  void recv_testInsertTablets(TSStatus& _return, const int32_t seqid);
  void testInsertRecord(TSStatus& _return, const TSInsertRecordReq& req);
  int32_t send_testInsertRecord(const TSInsertRecordReq& req);
  void recv_testInsertRecord(TSStatus& _return, const int32_t seqid);
  void testInsertStringRecord(TSStatus& _return, const TSInsertStringRecordReq& req);
  int32_t send_testInsertStringRecord(const TSInsertStringRecordReq& req);
  void recv_testInsertStringRecord(TSStatus& _return, const int32_t seqid);
  void testInsertRecords(TSStatus& _return, const TSInsertRecordsReq& req);
  int32_t send_testInsertRecords(const TSInsertRecordsReq& req);
  void recv_testInsertRecords(TSStatus& _return, const int32_t seqid);
  void testInsertRecordsOfOneDevice(TSStatus& _return, const TSInsertRecordsOfOneDeviceReq& req);
  int32_t send_testInsertRecordsOfOneDevice(const TSInsertRecordsOfOneDeviceReq& req);
  void recv_testInsertRecordsOfOneDevice(TSStatus& _return, const int32_t seqid);
  void testInsertStringRecords(TSStatus& _return, const TSInsertStringRecordsReq& req);
  int32_t send_testInsertStringRecords(const TSInsertStringRecordsReq& req);
  void recv_testInsertStringRecords(TSStatus& _return, const int32_t seqid);
  void deleteData(TSStatus& _return, const TSDeleteDataReq& req);
  int32_t send_deleteData(const TSDeleteDataReq& req);
  void recv_deleteData(TSStatus& _return, const int32_t seqid);
  void executeRawDataQuery(TSExecuteStatementResp& _return, const TSRawDataQueryReq& req);
  int32_t send_executeRawDataQuery(const TSRawDataQueryReq& req);
  void recv_executeRawDataQuery(TSExecuteStatementResp& _return, const int32_t seqid);
  int64_t requestStatementId(const int64_t sessionId);
  int32_t send_requestStatementId(const int64_t sessionId);
  int64_t recv_requestStatementId(const int32_t seqid);
 protected:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
  std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync_;
};

#ifdef _MSC_VER
  #pragma warning( pop )
#endif



#endif
