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

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

namespace milvus { namespace thrift {

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

class MilvusServiceIf {
 public:
  virtual ~MilvusServiceIf() {}

  /**
   * @brief Create table method
   * 
   * This method is used to create table
   * 
   * @param param, use to provide table information to be created.
   * 
   * 
   * @param param
   */
  virtual void CreateTable(const TableSchema& param) = 0;

  /**
   * @brief Test table existence method
   * 
   * This method is used to test table existence.
   * 
   * @param table_name, table name is going to be tested.
   * 
   * 
   * @param table_name
   */
  virtual bool HasTable(const std::string& table_name) = 0;

  /**
   * @brief Delete table method
   * 
   * This method is used to delete table.
   * 
   * @param table_name, table name is going to be deleted.
   * 
   * 
   * @param table_name
   */
  virtual void DeleteTable(const std::string& table_name) = 0;

  /**
   * @brief Build index by table method
   * 
   * This method is used to build index by table in sync mode.
   * 
   * @param table_name, table is going to be built index.
   * 
   * 
   * @param table_name
   */
  virtual void BuildIndex(const std::string& table_name) = 0;

  /**
   * @brief Add vector array to table
   * 
   * This method is used to add vector array to table.
   * 
   * @param table_name, table_name is inserted.
   * @param record_array, vector array is inserted.
   * 
   * @return vector id array
   * 
   * @param table_name
   * @param record_array
   */
  virtual void AddVector(std::vector<int64_t> & _return, const std::string& table_name, const std::vector<RowRecord> & record_array) = 0;

  /**
   * @brief Query vector
   * 
   * This method is used to query vector in table.
   * 
   * @param table_name, table_name is queried.
   * @param query_record_array, all vector are going to be queried.
   * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
   * @param topk, how many similarity vectors will be searched.
   * 
   * @return query result array.
   * 
   * @param table_name
   * @param query_record_array
   * @param query_range_array
   * @param topk
   */
  virtual void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) = 0;

  /**
   * @brief Internal use query interface
   * 
   * This method is used to query vector in specified files.
   * 
   * @param file_id_array, specified files id array, queried.
   * @param query_record_array, all vector are going to be queried.
   * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
   * @param topk, how many similarity vectors will be searched.
   * 
   * @return query result array.
   * 
   * @param table_name
   * @param file_id_array
   * @param query_record_array
   * @param query_range_array
   * @param topk
   */
  virtual void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) = 0;

  /**
   * @brief Get table schema
   * 
   * This method is used to get table schema.
   * 
   * @param table_name, target table name.
   * 
   * @return table schema
   * 
   * @param table_name
   */
  virtual void DescribeTable(TableSchema& _return, const std::string& table_name) = 0;

  /**
   * @brief Get table row count
   * 
   * This method is used to get table row count.
   * 
   * @param table_name, target table name.
   * 
   * @return table row count
   * 
   * @param table_name
   */
  virtual int64_t GetTableRowCount(const std::string& table_name) = 0;

  /**
   * @brief List all tables in database
   * 
   * This method is used to list all tables.
   * 
   * 
   * @return table names.
   */
  virtual void ShowTables(std::vector<std::string> & _return) = 0;

  /**
   * @brief Give the server status
   * 
   * This method is used to give the server status.
   * 
   * @return Server status.
   * 
   * @param cmd
   */
  virtual void Ping(std::string& _return, const std::string& cmd) = 0;
};

class MilvusServiceIfFactory {
 public:
  typedef MilvusServiceIf Handler;

  virtual ~MilvusServiceIfFactory() {}

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

class MilvusServiceIfSingletonFactory : virtual public MilvusServiceIfFactory {
 public:
  MilvusServiceIfSingletonFactory(const ::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf>& iface) : iface_(iface) {}
  virtual ~MilvusServiceIfSingletonFactory() {}

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

 protected:
  ::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> iface_;
};

class MilvusServiceNull : virtual public MilvusServiceIf {
 public:
  virtual ~MilvusServiceNull() {}
  void CreateTable(const TableSchema& /* param */) {
    return;
  }
  bool HasTable(const std::string& /* table_name */) {
    bool _return = false;
    return _return;
  }
  void DeleteTable(const std::string& /* table_name */) {
    return;
  }
  void BuildIndex(const std::string& /* table_name */) {
    return;
  }
  void AddVector(std::vector<int64_t> & /* _return */, const std::string& /* table_name */, const std::vector<RowRecord> & /* record_array */) {
    return;
  }
  void SearchVector(std::vector<TopKQueryResult> & /* _return */, const std::string& /* table_name */, const std::vector<RowRecord> & /* query_record_array */, const std::vector<Range> & /* query_range_array */, const int64_t /* topk */) {
    return;
  }
  void SearchVectorInFiles(std::vector<TopKQueryResult> & /* _return */, const std::string& /* table_name */, const std::vector<std::string> & /* file_id_array */, const std::vector<RowRecord> & /* query_record_array */, const std::vector<Range> & /* query_range_array */, const int64_t /* topk */) {
    return;
  }
  void DescribeTable(TableSchema& /* _return */, const std::string& /* table_name */) {
    return;
  }
  int64_t GetTableRowCount(const std::string& /* table_name */) {
    int64_t _return = 0;
    return _return;
  }
  void ShowTables(std::vector<std::string> & /* _return */) {
    return;
  }
  void Ping(std::string& /* _return */, const std::string& /* cmd */) {
    return;
  }
};

typedef struct _MilvusService_CreateTable_args__isset {
  _MilvusService_CreateTable_args__isset() : param(false) {}
  bool param :1;
} _MilvusService_CreateTable_args__isset;

class MilvusService_CreateTable_args {
 public:

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

  virtual ~MilvusService_CreateTable_args() throw();
  TableSchema param;

  _MilvusService_CreateTable_args__isset __isset;

  void __set_param(const TableSchema& val);

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

  bool operator < (const MilvusService_CreateTable_args & ) const;

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

};


class MilvusService_CreateTable_pargs {
 public:


  virtual ~MilvusService_CreateTable_pargs() throw();
  const TableSchema* param;

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

};

typedef struct _MilvusService_CreateTable_result__isset {
  _MilvusService_CreateTable_result__isset() : e(false) {}
  bool e :1;
} _MilvusService_CreateTable_result__isset;

class MilvusService_CreateTable_result {
 public:

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

  virtual ~MilvusService_CreateTable_result() throw();
  Exception e;

  _MilvusService_CreateTable_result__isset __isset;

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_CreateTable_result & ) const;

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

};

typedef struct _MilvusService_CreateTable_presult__isset {
  _MilvusService_CreateTable_presult__isset() : e(false) {}
  bool e :1;
} _MilvusService_CreateTable_presult__isset;

class MilvusService_CreateTable_presult {
 public:


  virtual ~MilvusService_CreateTable_presult() throw();
  Exception e;

  _MilvusService_CreateTable_presult__isset __isset;

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

};

typedef struct _MilvusService_HasTable_args__isset {
  _MilvusService_HasTable_args__isset() : table_name(false) {}
  bool table_name :1;
} _MilvusService_HasTable_args__isset;

class MilvusService_HasTable_args {
 public:

  MilvusService_HasTable_args(const MilvusService_HasTable_args&);
  MilvusService_HasTable_args& operator=(const MilvusService_HasTable_args&);
  MilvusService_HasTable_args() : table_name() {
  }

  virtual ~MilvusService_HasTable_args() throw();
  std::string table_name;

  _MilvusService_HasTable_args__isset __isset;

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

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

  bool operator < (const MilvusService_HasTable_args & ) const;

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

};


class MilvusService_HasTable_pargs {
 public:


  virtual ~MilvusService_HasTable_pargs() throw();
  const std::string* table_name;

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

};

typedef struct _MilvusService_HasTable_result__isset {
  _MilvusService_HasTable_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_HasTable_result__isset;

class MilvusService_HasTable_result {
 public:

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

  virtual ~MilvusService_HasTable_result() throw();
  bool success;
  Exception e;

  _MilvusService_HasTable_result__isset __isset;

  void __set_success(const bool val);

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_HasTable_result & ) const;

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

};

typedef struct _MilvusService_HasTable_presult__isset {
  _MilvusService_HasTable_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_HasTable_presult__isset;

class MilvusService_HasTable_presult {
 public:


  virtual ~MilvusService_HasTable_presult() throw();
  bool* success;
  Exception e;

  _MilvusService_HasTable_presult__isset __isset;

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

};

typedef struct _MilvusService_DeleteTable_args__isset {
  _MilvusService_DeleteTable_args__isset() : table_name(false) {}
  bool table_name :1;
} _MilvusService_DeleteTable_args__isset;

class MilvusService_DeleteTable_args {
 public:

  MilvusService_DeleteTable_args(const MilvusService_DeleteTable_args&);
  MilvusService_DeleteTable_args& operator=(const MilvusService_DeleteTable_args&);
  MilvusService_DeleteTable_args() : table_name() {
  }

  virtual ~MilvusService_DeleteTable_args() throw();
  std::string table_name;

  _MilvusService_DeleteTable_args__isset __isset;

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

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

  bool operator < (const MilvusService_DeleteTable_args & ) const;

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

};


class MilvusService_DeleteTable_pargs {
 public:


  virtual ~MilvusService_DeleteTable_pargs() throw();
  const std::string* table_name;

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

};

typedef struct _MilvusService_DeleteTable_result__isset {
  _MilvusService_DeleteTable_result__isset() : e(false) {}
  bool e :1;
} _MilvusService_DeleteTable_result__isset;

class MilvusService_DeleteTable_result {
 public:

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

  virtual ~MilvusService_DeleteTable_result() throw();
  Exception e;

  _MilvusService_DeleteTable_result__isset __isset;

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_DeleteTable_result & ) const;

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

};

typedef struct _MilvusService_DeleteTable_presult__isset {
  _MilvusService_DeleteTable_presult__isset() : e(false) {}
  bool e :1;
} _MilvusService_DeleteTable_presult__isset;

class MilvusService_DeleteTable_presult {
 public:


  virtual ~MilvusService_DeleteTable_presult() throw();
  Exception e;

  _MilvusService_DeleteTable_presult__isset __isset;

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

};

typedef struct _MilvusService_BuildIndex_args__isset {
  _MilvusService_BuildIndex_args__isset() : table_name(false) {}
  bool table_name :1;
} _MilvusService_BuildIndex_args__isset;

class MilvusService_BuildIndex_args {
 public:

  MilvusService_BuildIndex_args(const MilvusService_BuildIndex_args&);
  MilvusService_BuildIndex_args& operator=(const MilvusService_BuildIndex_args&);
  MilvusService_BuildIndex_args() : table_name() {
  }

  virtual ~MilvusService_BuildIndex_args() throw();
  std::string table_name;

  _MilvusService_BuildIndex_args__isset __isset;

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

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

  bool operator < (const MilvusService_BuildIndex_args & ) const;

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

};


class MilvusService_BuildIndex_pargs {
 public:


  virtual ~MilvusService_BuildIndex_pargs() throw();
  const std::string* table_name;

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

};

typedef struct _MilvusService_BuildIndex_result__isset {
  _MilvusService_BuildIndex_result__isset() : e(false) {}
  bool e :1;
} _MilvusService_BuildIndex_result__isset;

class MilvusService_BuildIndex_result {
 public:

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

  virtual ~MilvusService_BuildIndex_result() throw();
  Exception e;

  _MilvusService_BuildIndex_result__isset __isset;

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_BuildIndex_result & ) const;

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

};

typedef struct _MilvusService_BuildIndex_presult__isset {
  _MilvusService_BuildIndex_presult__isset() : e(false) {}
  bool e :1;
} _MilvusService_BuildIndex_presult__isset;

class MilvusService_BuildIndex_presult {
 public:


  virtual ~MilvusService_BuildIndex_presult() throw();
  Exception e;

  _MilvusService_BuildIndex_presult__isset __isset;

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

};

typedef struct _MilvusService_AddVector_args__isset {
  _MilvusService_AddVector_args__isset() : table_name(false), record_array(false) {}
  bool table_name :1;
  bool record_array :1;
} _MilvusService_AddVector_args__isset;

class MilvusService_AddVector_args {
 public:

  MilvusService_AddVector_args(const MilvusService_AddVector_args&);
  MilvusService_AddVector_args& operator=(const MilvusService_AddVector_args&);
  MilvusService_AddVector_args() : table_name() {
  }

  virtual ~MilvusService_AddVector_args() throw();
  std::string table_name;
  std::vector<RowRecord>  record_array;

  _MilvusService_AddVector_args__isset __isset;

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

  void __set_record_array(const std::vector<RowRecord> & val);

  bool operator == (const MilvusService_AddVector_args & rhs) const
  {
    if (!(table_name == rhs.table_name))
      return false;
    if (!(record_array == rhs.record_array))
      return false;
    return true;
  }
  bool operator != (const MilvusService_AddVector_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MilvusService_AddVector_args & ) const;

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

};


class MilvusService_AddVector_pargs {
 public:


  virtual ~MilvusService_AddVector_pargs() throw();
  const std::string* table_name;
  const std::vector<RowRecord> * record_array;

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

};

typedef struct _MilvusService_AddVector_result__isset {
  _MilvusService_AddVector_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_AddVector_result__isset;

class MilvusService_AddVector_result {
 public:

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

  virtual ~MilvusService_AddVector_result() throw();
  std::vector<int64_t>  success;
  Exception e;

  _MilvusService_AddVector_result__isset __isset;

  void __set_success(const std::vector<int64_t> & val);

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_AddVector_result & ) const;

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

};

typedef struct _MilvusService_AddVector_presult__isset {
  _MilvusService_AddVector_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_AddVector_presult__isset;

class MilvusService_AddVector_presult {
 public:


  virtual ~MilvusService_AddVector_presult() throw();
  std::vector<int64_t> * success;
  Exception e;

  _MilvusService_AddVector_presult__isset __isset;

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

};

typedef struct _MilvusService_SearchVector_args__isset {
  _MilvusService_SearchVector_args__isset() : table_name(false), query_record_array(false), query_range_array(false), topk(false) {}
  bool table_name :1;
  bool query_record_array :1;
  bool query_range_array :1;
  bool topk :1;
} _MilvusService_SearchVector_args__isset;

class MilvusService_SearchVector_args {
 public:

  MilvusService_SearchVector_args(const MilvusService_SearchVector_args&);
  MilvusService_SearchVector_args& operator=(const MilvusService_SearchVector_args&);
  MilvusService_SearchVector_args() : table_name(), topk(0) {
  }

  virtual ~MilvusService_SearchVector_args() throw();
  std::string table_name;
  std::vector<RowRecord>  query_record_array;
  std::vector<Range>  query_range_array;
  int64_t topk;

  _MilvusService_SearchVector_args__isset __isset;

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

  void __set_query_record_array(const std::vector<RowRecord> & val);

  void __set_query_range_array(const std::vector<Range> & val);

  void __set_topk(const int64_t val);

  bool operator == (const MilvusService_SearchVector_args & rhs) const
  {
    if (!(table_name == rhs.table_name))
      return false;
    if (!(query_record_array == rhs.query_record_array))
      return false;
    if (!(query_range_array == rhs.query_range_array))
      return false;
    if (!(topk == rhs.topk))
      return false;
    return true;
  }
  bool operator != (const MilvusService_SearchVector_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MilvusService_SearchVector_args & ) const;

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

};


class MilvusService_SearchVector_pargs {
 public:


  virtual ~MilvusService_SearchVector_pargs() throw();
  const std::string* table_name;
  const std::vector<RowRecord> * query_record_array;
  const std::vector<Range> * query_range_array;
  const int64_t* topk;

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

};

typedef struct _MilvusService_SearchVector_result__isset {
  _MilvusService_SearchVector_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_SearchVector_result__isset;

class MilvusService_SearchVector_result {
 public:

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

  virtual ~MilvusService_SearchVector_result() throw();
  std::vector<TopKQueryResult>  success;
  Exception e;

  _MilvusService_SearchVector_result__isset __isset;

  void __set_success(const std::vector<TopKQueryResult> & val);

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_SearchVector_result & ) const;

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

};

typedef struct _MilvusService_SearchVector_presult__isset {
  _MilvusService_SearchVector_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_SearchVector_presult__isset;

class MilvusService_SearchVector_presult {
 public:


  virtual ~MilvusService_SearchVector_presult() throw();
  std::vector<TopKQueryResult> * success;
  Exception e;

  _MilvusService_SearchVector_presult__isset __isset;

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

};

typedef struct _MilvusService_SearchVectorInFiles_args__isset {
  _MilvusService_SearchVectorInFiles_args__isset() : table_name(false), file_id_array(false), query_record_array(false), query_range_array(false), topk(false) {}
  bool table_name :1;
  bool file_id_array :1;
  bool query_record_array :1;
  bool query_range_array :1;
  bool topk :1;
} _MilvusService_SearchVectorInFiles_args__isset;

class MilvusService_SearchVectorInFiles_args {
 public:

  MilvusService_SearchVectorInFiles_args(const MilvusService_SearchVectorInFiles_args&);
  MilvusService_SearchVectorInFiles_args& operator=(const MilvusService_SearchVectorInFiles_args&);
  MilvusService_SearchVectorInFiles_args() : table_name(), topk(0) {
  }

  virtual ~MilvusService_SearchVectorInFiles_args() throw();
  std::string table_name;
  std::vector<std::string>  file_id_array;
  std::vector<RowRecord>  query_record_array;
  std::vector<Range>  query_range_array;
  int64_t topk;

  _MilvusService_SearchVectorInFiles_args__isset __isset;

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

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

  void __set_query_record_array(const std::vector<RowRecord> & val);

  void __set_query_range_array(const std::vector<Range> & val);

  void __set_topk(const int64_t val);

  bool operator == (const MilvusService_SearchVectorInFiles_args & rhs) const
  {
    if (!(table_name == rhs.table_name))
      return false;
    if (!(file_id_array == rhs.file_id_array))
      return false;
    if (!(query_record_array == rhs.query_record_array))
      return false;
    if (!(query_range_array == rhs.query_range_array))
      return false;
    if (!(topk == rhs.topk))
      return false;
    return true;
  }
  bool operator != (const MilvusService_SearchVectorInFiles_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MilvusService_SearchVectorInFiles_args & ) const;

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

};


class MilvusService_SearchVectorInFiles_pargs {
 public:


  virtual ~MilvusService_SearchVectorInFiles_pargs() throw();
  const std::string* table_name;
  const std::vector<std::string> * file_id_array;
  const std::vector<RowRecord> * query_record_array;
  const std::vector<Range> * query_range_array;
  const int64_t* topk;

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

};

typedef struct _MilvusService_SearchVectorInFiles_result__isset {
  _MilvusService_SearchVectorInFiles_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_SearchVectorInFiles_result__isset;

class MilvusService_SearchVectorInFiles_result {
 public:

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

  virtual ~MilvusService_SearchVectorInFiles_result() throw();
  std::vector<TopKQueryResult>  success;
  Exception e;

  _MilvusService_SearchVectorInFiles_result__isset __isset;

  void __set_success(const std::vector<TopKQueryResult> & val);

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_SearchVectorInFiles_result & ) const;

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

};

typedef struct _MilvusService_SearchVectorInFiles_presult__isset {
  _MilvusService_SearchVectorInFiles_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_SearchVectorInFiles_presult__isset;

class MilvusService_SearchVectorInFiles_presult {
 public:


  virtual ~MilvusService_SearchVectorInFiles_presult() throw();
  std::vector<TopKQueryResult> * success;
  Exception e;

  _MilvusService_SearchVectorInFiles_presult__isset __isset;

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

};

typedef struct _MilvusService_DescribeTable_args__isset {
  _MilvusService_DescribeTable_args__isset() : table_name(false) {}
  bool table_name :1;
} _MilvusService_DescribeTable_args__isset;

class MilvusService_DescribeTable_args {
 public:

  MilvusService_DescribeTable_args(const MilvusService_DescribeTable_args&);
  MilvusService_DescribeTable_args& operator=(const MilvusService_DescribeTable_args&);
  MilvusService_DescribeTable_args() : table_name() {
  }

  virtual ~MilvusService_DescribeTable_args() throw();
  std::string table_name;

  _MilvusService_DescribeTable_args__isset __isset;

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

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

  bool operator < (const MilvusService_DescribeTable_args & ) const;

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

};


class MilvusService_DescribeTable_pargs {
 public:


  virtual ~MilvusService_DescribeTable_pargs() throw();
  const std::string* table_name;

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

};

typedef struct _MilvusService_DescribeTable_result__isset {
  _MilvusService_DescribeTable_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_DescribeTable_result__isset;

class MilvusService_DescribeTable_result {
 public:

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

  virtual ~MilvusService_DescribeTable_result() throw();
  TableSchema success;
  Exception e;

  _MilvusService_DescribeTable_result__isset __isset;

  void __set_success(const TableSchema& val);

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_DescribeTable_result & ) const;

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

};

typedef struct _MilvusService_DescribeTable_presult__isset {
  _MilvusService_DescribeTable_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_DescribeTable_presult__isset;

class MilvusService_DescribeTable_presult {
 public:


  virtual ~MilvusService_DescribeTable_presult() throw();
  TableSchema* success;
  Exception e;

  _MilvusService_DescribeTable_presult__isset __isset;

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

};

typedef struct _MilvusService_GetTableRowCount_args__isset {
  _MilvusService_GetTableRowCount_args__isset() : table_name(false) {}
  bool table_name :1;
} _MilvusService_GetTableRowCount_args__isset;

class MilvusService_GetTableRowCount_args {
 public:

  MilvusService_GetTableRowCount_args(const MilvusService_GetTableRowCount_args&);
  MilvusService_GetTableRowCount_args& operator=(const MilvusService_GetTableRowCount_args&);
  MilvusService_GetTableRowCount_args() : table_name() {
  }

  virtual ~MilvusService_GetTableRowCount_args() throw();
  std::string table_name;

  _MilvusService_GetTableRowCount_args__isset __isset;

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

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

  bool operator < (const MilvusService_GetTableRowCount_args & ) const;

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

};


class MilvusService_GetTableRowCount_pargs {
 public:


  virtual ~MilvusService_GetTableRowCount_pargs() throw();
  const std::string* table_name;

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

};

typedef struct _MilvusService_GetTableRowCount_result__isset {
  _MilvusService_GetTableRowCount_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_GetTableRowCount_result__isset;

class MilvusService_GetTableRowCount_result {
 public:

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

  virtual ~MilvusService_GetTableRowCount_result() throw();
  int64_t success;
  Exception e;

  _MilvusService_GetTableRowCount_result__isset __isset;

  void __set_success(const int64_t val);

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_GetTableRowCount_result & ) const;

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

};

typedef struct _MilvusService_GetTableRowCount_presult__isset {
  _MilvusService_GetTableRowCount_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_GetTableRowCount_presult__isset;

class MilvusService_GetTableRowCount_presult {
 public:


  virtual ~MilvusService_GetTableRowCount_presult() throw();
  int64_t* success;
  Exception e;

  _MilvusService_GetTableRowCount_presult__isset __isset;

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

};


class MilvusService_ShowTables_args {
 public:

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

  virtual ~MilvusService_ShowTables_args() throw();

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

  bool operator < (const MilvusService_ShowTables_args & ) const;

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

};


class MilvusService_ShowTables_pargs {
 public:


  virtual ~MilvusService_ShowTables_pargs() throw();

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

};

typedef struct _MilvusService_ShowTables_result__isset {
  _MilvusService_ShowTables_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_ShowTables_result__isset;

class MilvusService_ShowTables_result {
 public:

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

  virtual ~MilvusService_ShowTables_result() throw();
  std::vector<std::string>  success;
  Exception e;

  _MilvusService_ShowTables_result__isset __isset;

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

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_ShowTables_result & ) const;

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

};

typedef struct _MilvusService_ShowTables_presult__isset {
  _MilvusService_ShowTables_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_ShowTables_presult__isset;

class MilvusService_ShowTables_presult {
 public:


  virtual ~MilvusService_ShowTables_presult() throw();
  std::vector<std::string> * success;
  Exception e;

  _MilvusService_ShowTables_presult__isset __isset;

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

};

typedef struct _MilvusService_Ping_args__isset {
  _MilvusService_Ping_args__isset() : cmd(false) {}
  bool cmd :1;
} _MilvusService_Ping_args__isset;

class MilvusService_Ping_args {
 public:

  MilvusService_Ping_args(const MilvusService_Ping_args&);
  MilvusService_Ping_args& operator=(const MilvusService_Ping_args&);
  MilvusService_Ping_args() : cmd() {
  }

  virtual ~MilvusService_Ping_args() throw();
  std::string cmd;

  _MilvusService_Ping_args__isset __isset;

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

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

  bool operator < (const MilvusService_Ping_args & ) const;

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

};


class MilvusService_Ping_pargs {
 public:


  virtual ~MilvusService_Ping_pargs() throw();
  const std::string* cmd;

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

};

typedef struct _MilvusService_Ping_result__isset {
  _MilvusService_Ping_result__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_Ping_result__isset;

class MilvusService_Ping_result {
 public:

  MilvusService_Ping_result(const MilvusService_Ping_result&);
  MilvusService_Ping_result& operator=(const MilvusService_Ping_result&);
  MilvusService_Ping_result() : success() {
  }

  virtual ~MilvusService_Ping_result() throw();
  std::string success;
  Exception e;

  _MilvusService_Ping_result__isset __isset;

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

  void __set_e(const Exception& val);

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

  bool operator < (const MilvusService_Ping_result & ) const;

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

};

typedef struct _MilvusService_Ping_presult__isset {
  _MilvusService_Ping_presult__isset() : success(false), e(false) {}
  bool success :1;
  bool e :1;
} _MilvusService_Ping_presult__isset;

class MilvusService_Ping_presult {
 public:


  virtual ~MilvusService_Ping_presult() throw();
  std::string* success;
  Exception e;

  _MilvusService_Ping_presult__isset __isset;

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

};

class MilvusServiceClient : virtual public MilvusServiceIf {
 public:
  MilvusServiceClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  MilvusServiceClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void CreateTable(const TableSchema& param);
  void send_CreateTable(const TableSchema& param);
  void recv_CreateTable();
  bool HasTable(const std::string& table_name);
  void send_HasTable(const std::string& table_name);
  bool recv_HasTable();
  void DeleteTable(const std::string& table_name);
  void send_DeleteTable(const std::string& table_name);
  void recv_DeleteTable();
  void BuildIndex(const std::string& table_name);
  void send_BuildIndex(const std::string& table_name);
  void recv_BuildIndex();
  void AddVector(std::vector<int64_t> & _return, const std::string& table_name, const std::vector<RowRecord> & record_array);
  void send_AddVector(const std::string& table_name, const std::vector<RowRecord> & record_array);
  void recv_AddVector(std::vector<int64_t> & _return);
  void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  void send_SearchVector(const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  void recv_SearchVector(std::vector<TopKQueryResult> & _return);
  void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  void send_SearchVectorInFiles(const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  void recv_SearchVectorInFiles(std::vector<TopKQueryResult> & _return);
  void DescribeTable(TableSchema& _return, const std::string& table_name);
  void send_DescribeTable(const std::string& table_name);
  void recv_DescribeTable(TableSchema& _return);
  int64_t GetTableRowCount(const std::string& table_name);
  void send_GetTableRowCount(const std::string& table_name);
  int64_t recv_GetTableRowCount();
  void ShowTables(std::vector<std::string> & _return);
  void send_ShowTables();
  void recv_ShowTables(std::vector<std::string> & _return);
  void Ping(std::string& _return, const std::string& cmd);
  void send_Ping(const std::string& cmd);
  void recv_Ping(std::string& _return);
 protected:
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class MilvusServiceProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  ::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> 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 (MilvusServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_CreateTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_HasTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_DeleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_BuildIndex(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_AddVector(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_SearchVector(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_SearchVectorInFiles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_DescribeTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetTableRowCount(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_ShowTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_Ping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  MilvusServiceProcessor(::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> iface) :
    iface_(iface) {
    processMap_["CreateTable"] = &MilvusServiceProcessor::process_CreateTable;
    processMap_["HasTable"] = &MilvusServiceProcessor::process_HasTable;
    processMap_["DeleteTable"] = &MilvusServiceProcessor::process_DeleteTable;
    processMap_["BuildIndex"] = &MilvusServiceProcessor::process_BuildIndex;
    processMap_["AddVector"] = &MilvusServiceProcessor::process_AddVector;
    processMap_["SearchVector"] = &MilvusServiceProcessor::process_SearchVector;
    processMap_["SearchVectorInFiles"] = &MilvusServiceProcessor::process_SearchVectorInFiles;
    processMap_["DescribeTable"] = &MilvusServiceProcessor::process_DescribeTable;
    processMap_["GetTableRowCount"] = &MilvusServiceProcessor::process_GetTableRowCount;
    processMap_["ShowTables"] = &MilvusServiceProcessor::process_ShowTables;
    processMap_["Ping"] = &MilvusServiceProcessor::process_Ping;
  }

  virtual ~MilvusServiceProcessor() {}
};

class MilvusServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  MilvusServiceProcessorFactory(const ::apache::thrift::stdcxx::shared_ptr< MilvusServiceIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

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

 protected:
  ::apache::thrift::stdcxx::shared_ptr< MilvusServiceIfFactory > handlerFactory_;
};

class MilvusServiceMultiface : virtual public MilvusServiceIf {
 public:
  MilvusServiceMultiface(std::vector<apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~MilvusServiceMultiface() {}
 protected:
  std::vector<apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> > ifaces_;
  MilvusServiceMultiface() {}
  void add(::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void CreateTable(const TableSchema& param) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CreateTable(param);
    }
    ifaces_[i]->CreateTable(param);
  }

  bool HasTable(const std::string& table_name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->HasTable(table_name);
    }
    return ifaces_[i]->HasTable(table_name);
  }

  void DeleteTable(const std::string& table_name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->DeleteTable(table_name);
    }
    ifaces_[i]->DeleteTable(table_name);
  }

  void BuildIndex(const std::string& table_name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->BuildIndex(table_name);
    }
    ifaces_[i]->BuildIndex(table_name);
  }

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

  void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->SearchVector(_return, table_name, query_record_array, query_range_array, topk);
    }
    ifaces_[i]->SearchVector(_return, table_name, query_record_array, query_range_array, topk);
    return;
  }

  void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->SearchVectorInFiles(_return, table_name, file_id_array, query_record_array, query_range_array, topk);
    }
    ifaces_[i]->SearchVectorInFiles(_return, table_name, file_id_array, query_record_array, query_range_array, topk);
    return;
  }

  void DescribeTable(TableSchema& _return, const std::string& table_name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->DescribeTable(_return, table_name);
    }
    ifaces_[i]->DescribeTable(_return, table_name);
    return;
  }

  int64_t GetTableRowCount(const std::string& table_name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetTableRowCount(table_name);
    }
    return ifaces_[i]->GetTableRowCount(table_name);
  }

  void ShowTables(std::vector<std::string> & _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->ShowTables(_return);
    }
    ifaces_[i]->ShowTables(_return);
    return;
  }

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

};

// The 'concurrent' client is a thread safe client that correctly handles
// out of order responses.  It is slower than the regular client, so should
// only be used when you need to share a connection among multiple threads
class MilvusServiceConcurrentClient : virtual public MilvusServiceIf {
 public:
  MilvusServiceConcurrentClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  MilvusServiceConcurrentClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void CreateTable(const TableSchema& param);
  int32_t send_CreateTable(const TableSchema& param);
  void recv_CreateTable(const int32_t seqid);
  bool HasTable(const std::string& table_name);
  int32_t send_HasTable(const std::string& table_name);
  bool recv_HasTable(const int32_t seqid);
  void DeleteTable(const std::string& table_name);
  int32_t send_DeleteTable(const std::string& table_name);
  void recv_DeleteTable(const int32_t seqid);
  void BuildIndex(const std::string& table_name);
  int32_t send_BuildIndex(const std::string& table_name);
  void recv_BuildIndex(const int32_t seqid);
  void AddVector(std::vector<int64_t> & _return, const std::string& table_name, const std::vector<RowRecord> & record_array);
  int32_t send_AddVector(const std::string& table_name, const std::vector<RowRecord> & record_array);
  void recv_AddVector(std::vector<int64_t> & _return, const int32_t seqid);
  void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  int32_t send_SearchVector(const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  void recv_SearchVector(std::vector<TopKQueryResult> & _return, const int32_t seqid);
  void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  int32_t send_SearchVectorInFiles(const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
  void recv_SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const int32_t seqid);
  void DescribeTable(TableSchema& _return, const std::string& table_name);
  int32_t send_DescribeTable(const std::string& table_name);
  void recv_DescribeTable(TableSchema& _return, const int32_t seqid);
  int64_t GetTableRowCount(const std::string& table_name);
  int32_t send_GetTableRowCount(const std::string& table_name);
  int64_t recv_GetTableRowCount(const int32_t seqid);
  void ShowTables(std::vector<std::string> & _return);
  int32_t send_ShowTables();
  void recv_ShowTables(std::vector<std::string> & _return, const int32_t seqid);
  void Ping(std::string& _return, const std::string& cmd);
  int32_t send_Ping(const std::string& cmd);
  void recv_Ping(std::string& _return, const int32_t seqid);
 protected:
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
  ::apache::thrift::async::TConcurrentClientSyncInfo sync_;
};

#ifdef _MSC_VER
  #pragma warning( pop )
#endif

}} // namespace

#endif