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

#include <thrift/TDispatchProcessor.h>
#include "querytele_types.h"

namespace querytele {

class QueryTeleServiceIf {
 public:
  virtual ~QueryTeleServiceIf() {}
  virtual void postQuery(const QueryTele& query) = 0;
  virtual void postStep(const StepTele& query) = 0;
  virtual void postImport(const ImportTele& query) = 0;
};

class QueryTeleServiceIfFactory {
 public:
  typedef QueryTeleServiceIf Handler;

  virtual ~QueryTeleServiceIfFactory() {}

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

class QueryTeleServiceIfSingletonFactory : virtual public QueryTeleServiceIfFactory {
 public:
  QueryTeleServiceIfSingletonFactory(const boost::shared_ptr<QueryTeleServiceIf>& iface) : iface_(iface) {}
  virtual ~QueryTeleServiceIfSingletonFactory() {}

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

 protected:
  boost::shared_ptr<QueryTeleServiceIf> iface_;
};

class QueryTeleServiceNull : virtual public QueryTeleServiceIf {
 public:
  virtual ~QueryTeleServiceNull() {}
  void postQuery(const QueryTele& /* query */) {
    return;
  }
  void postStep(const StepTele& /* query */) {
    return;
  }
  void postImport(const ImportTele& /* query */) {
    return;
  }
};

typedef struct _QueryTeleService_postQuery_args__isset {
  _QueryTeleService_postQuery_args__isset() : query(false) {}
  bool query;
} _QueryTeleService_postQuery_args__isset;

class QueryTeleService_postQuery_args {
 public:

  QueryTeleService_postQuery_args() {
  }

  virtual ~QueryTeleService_postQuery_args() throw() {}

  QueryTele query;

  _QueryTeleService_postQuery_args__isset __isset;

  void __set_query(const QueryTele& val) {
    query = val;
  }

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

  bool operator < (const QueryTeleService_postQuery_args & ) const;

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

};


class QueryTeleService_postQuery_pargs {
 public:


  virtual ~QueryTeleService_postQuery_pargs() throw() {}

  const QueryTele* query;

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

};


class QueryTeleService_postQuery_result {
 public:

  QueryTeleService_postQuery_result() {
  }

  virtual ~QueryTeleService_postQuery_result() throw() {}


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

  bool operator < (const QueryTeleService_postQuery_result & ) const;

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

};


class QueryTeleService_postQuery_presult {
 public:


  virtual ~QueryTeleService_postQuery_presult() throw() {}


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

};

typedef struct _QueryTeleService_postStep_args__isset {
  _QueryTeleService_postStep_args__isset() : query(false) {}
  bool query;
} _QueryTeleService_postStep_args__isset;

class QueryTeleService_postStep_args {
 public:

  QueryTeleService_postStep_args() {
  }

  virtual ~QueryTeleService_postStep_args() throw() {}

  StepTele query;

  _QueryTeleService_postStep_args__isset __isset;

  void __set_query(const StepTele& val) {
    query = val;
  }

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

  bool operator < (const QueryTeleService_postStep_args & ) const;

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

};


class QueryTeleService_postStep_pargs {
 public:


  virtual ~QueryTeleService_postStep_pargs() throw() {}

  const StepTele* query;

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

};


class QueryTeleService_postStep_result {
 public:

  QueryTeleService_postStep_result() {
  }

  virtual ~QueryTeleService_postStep_result() throw() {}


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

  bool operator < (const QueryTeleService_postStep_result & ) const;

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

};


class QueryTeleService_postStep_presult {
 public:


  virtual ~QueryTeleService_postStep_presult() throw() {}


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

};

typedef struct _QueryTeleService_postImport_args__isset {
  _QueryTeleService_postImport_args__isset() : query(false) {}
  bool query;
} _QueryTeleService_postImport_args__isset;

class QueryTeleService_postImport_args {
 public:

  QueryTeleService_postImport_args() {
  }

  virtual ~QueryTeleService_postImport_args() throw() {}

  ImportTele query;

  _QueryTeleService_postImport_args__isset __isset;

  void __set_query(const ImportTele& val) {
    query = val;
  }

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

  bool operator < (const QueryTeleService_postImport_args & ) const;

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

};


class QueryTeleService_postImport_pargs {
 public:


  virtual ~QueryTeleService_postImport_pargs() throw() {}

  const ImportTele* query;

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

};


class QueryTeleService_postImport_result {
 public:

  QueryTeleService_postImport_result() {
  }

  virtual ~QueryTeleService_postImport_result() throw() {}


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

  bool operator < (const QueryTeleService_postImport_result & ) const;

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

};


class QueryTeleService_postImport_presult {
 public:


  virtual ~QueryTeleService_postImport_presult() throw() {}


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

};

class QueryTeleServiceClient : virtual public QueryTeleServiceIf {
 public:
  QueryTeleServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
    piprot_(prot),
    poprot_(prot) {
    iprot_ = prot.get();
    oprot_ = prot.get();
  }
  QueryTeleServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
    piprot_(iprot),
    poprot_(oprot) {
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void postQuery(const QueryTele& query);
  void send_postQuery(const QueryTele& query);
  void recv_postQuery();
  void postStep(const StepTele& query);
  void send_postStep(const StepTele& query);
  void recv_postStep();
  void postImport(const ImportTele& query);
  void send_postImport(const ImportTele& query);
  void recv_postImport();
 protected:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class QueryTeleServiceProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  boost::shared_ptr<QueryTeleServiceIf> 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 (QueryTeleServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_postQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_postStep(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_postImport(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  QueryTeleServiceProcessor(boost::shared_ptr<QueryTeleServiceIf> iface) :
    iface_(iface) {
    processMap_["postQuery"] = &QueryTeleServiceProcessor::process_postQuery;
    processMap_["postStep"] = &QueryTeleServiceProcessor::process_postStep;
    processMap_["postImport"] = &QueryTeleServiceProcessor::process_postImport;
  }

  virtual ~QueryTeleServiceProcessor() {}
};

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

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

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

class QueryTeleServiceMultiface : virtual public QueryTeleServiceIf {
 public:
  QueryTeleServiceMultiface(std::vector<boost::shared_ptr<QueryTeleServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~QueryTeleServiceMultiface() {}
 protected:
  std::vector<boost::shared_ptr<QueryTeleServiceIf> > ifaces_;
  QueryTeleServiceMultiface() {}
  void add(boost::shared_ptr<QueryTeleServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void postQuery(const QueryTele& query) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->postQuery(query);
    }
    ifaces_[i]->postQuery(query);
  }

  void postStep(const StepTele& query) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->postStep(query);
    }
    ifaces_[i]->postStep(query);
  }

  void postImport(const ImportTele& query) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->postImport(query);
    }
    ifaces_[i]->postImport(query);
  }

};

} // namespace

#endif