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

#include <thrift/transport/TBufferTransports.h>
#include <functional>
namespace apache { namespace thrift { namespace async {
class TAsyncChannel;
}}}
#include <thrift/TDispatchProcessor.h>
#include <thrift/async/TAsyncDispatchProcessor.h>
#include <thrift/async/TConcurrentClientSyncInfo.h>
#include <memory>
#include "proc_types.h"

namespace apache { namespace thrift { namespace test {

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

class ParentServiceIf {
 public:
  virtual ~ParentServiceIf() {}
  virtual int32_t incrementGeneration() = 0;
  virtual int32_t getGeneration() = 0;
  virtual void addString(const std::string& s) = 0;
  virtual void getStrings(std::vector<std::string> & _return) = 0;
  virtual void getDataWait(std::string& _return, const int32_t length) = 0;
  virtual void onewayWait() = 0;
  virtual void exceptionWait(const std::string& message) = 0;
  virtual void unexpectedExceptionWait(const std::string& message) = 0;
};

class ParentServiceIfFactory {
 public:
  typedef ParentServiceIf Handler;

  virtual ~ParentServiceIfFactory() {}

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

class ParentServiceIfSingletonFactory : virtual public ParentServiceIfFactory {
 public:
  ParentServiceIfSingletonFactory(const ::std::shared_ptr<ParentServiceIf>& iface) : iface_(iface) {}
  virtual ~ParentServiceIfSingletonFactory() {}

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

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

class ParentServiceNull : virtual public ParentServiceIf {
 public:
  virtual ~ParentServiceNull() {}
  int32_t incrementGeneration() {
    int32_t _return = 0;
    return _return;
  }
  int32_t getGeneration() {
    int32_t _return = 0;
    return _return;
  }
  void addString(const std::string& /* s */) {
    return;
  }
  void getStrings(std::vector<std::string> & /* _return */) {
    return;
  }
  void getDataWait(std::string& /* _return */, const int32_t /* length */) {
    return;
  }
  void onewayWait() {
    return;
  }
  void exceptionWait(const std::string& /* message */) {
    return;
  }
  void unexpectedExceptionWait(const std::string& /* message */) {
    return;
  }
};


class ParentService_incrementGeneration_args {
 public:

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

  virtual ~ParentService_incrementGeneration_args() noexcept;

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

  bool operator < (const ParentService_incrementGeneration_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_incrementGeneration_pargs {
 public:


  virtual ~ParentService_incrementGeneration_pargs() noexcept;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_incrementGeneration_result {
 public:

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

  virtual ~ParentService_incrementGeneration_result() noexcept;
  int32_t success;

  _ParentService_incrementGeneration_result__isset __isset;

  void __set_success(const int32_t val);

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

  bool operator < (const ParentService_incrementGeneration_result & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_incrementGeneration_presult {
 public:


  virtual ~ParentService_incrementGeneration_presult() noexcept;
  int32_t* success;

  _ParentService_incrementGeneration_presult__isset __isset;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_getGeneration_args {
 public:

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

  virtual ~ParentService_getGeneration_args() noexcept;

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

  bool operator < (const ParentService_getGeneration_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_getGeneration_pargs {
 public:


  virtual ~ParentService_getGeneration_pargs() noexcept;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_getGeneration_result {
 public:

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

  virtual ~ParentService_getGeneration_result() noexcept;
  int32_t success;

  _ParentService_getGeneration_result__isset __isset;

  void __set_success(const int32_t val);

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

  bool operator < (const ParentService_getGeneration_result & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_getGeneration_presult {
 public:


  virtual ~ParentService_getGeneration_presult() noexcept;
  int32_t* success;

  _ParentService_getGeneration_presult__isset __isset;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

typedef struct _ParentService_addString_args__isset {
  _ParentService_addString_args__isset() : s(false) {}
  bool s :1;
} _ParentService_addString_args__isset;

class ParentService_addString_args {
 public:

  ParentService_addString_args(const ParentService_addString_args&);
  ParentService_addString_args& operator=(const ParentService_addString_args&);
  ParentService_addString_args() : s() {
  }

  virtual ~ParentService_addString_args() noexcept;
  std::string s;

  _ParentService_addString_args__isset __isset;

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

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

  bool operator < (const ParentService_addString_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_addString_pargs {
 public:


  virtual ~ParentService_addString_pargs() noexcept;
  const std::string* s;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_addString_result {
 public:

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

  virtual ~ParentService_addString_result() noexcept;

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

  bool operator < (const ParentService_addString_result & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_addString_presult {
 public:


  virtual ~ParentService_addString_presult() noexcept;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_getStrings_args {
 public:

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

  virtual ~ParentService_getStrings_args() noexcept;

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

  bool operator < (const ParentService_getStrings_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_getStrings_pargs {
 public:


  virtual ~ParentService_getStrings_pargs() noexcept;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_getStrings_result {
 public:

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

  virtual ~ParentService_getStrings_result() noexcept;
  std::vector<std::string>  success;

  _ParentService_getStrings_result__isset __isset;

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

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

  bool operator < (const ParentService_getStrings_result & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_getStrings_presult {
 public:


  virtual ~ParentService_getStrings_presult() noexcept;
  std::vector<std::string> * success;

  _ParentService_getStrings_presult__isset __isset;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

typedef struct _ParentService_getDataWait_args__isset {
  _ParentService_getDataWait_args__isset() : length(false) {}
  bool length :1;
} _ParentService_getDataWait_args__isset;

class ParentService_getDataWait_args {
 public:

  ParentService_getDataWait_args(const ParentService_getDataWait_args&);
  ParentService_getDataWait_args& operator=(const ParentService_getDataWait_args&);
  ParentService_getDataWait_args() : length(0) {
  }

  virtual ~ParentService_getDataWait_args() noexcept;
  int32_t length;

  _ParentService_getDataWait_args__isset __isset;

  void __set_length(const int32_t val);

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

  bool operator < (const ParentService_getDataWait_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_getDataWait_pargs {
 public:


  virtual ~ParentService_getDataWait_pargs() noexcept;
  const int32_t* length;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_getDataWait_result {
 public:

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

  virtual ~ParentService_getDataWait_result() noexcept;
  std::string success;

  _ParentService_getDataWait_result__isset __isset;

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

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

  bool operator < (const ParentService_getDataWait_result & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

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

class ParentService_getDataWait_presult {
 public:


  virtual ~ParentService_getDataWait_presult() noexcept;
  std::string* success;

  _ParentService_getDataWait_presult__isset __isset;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_onewayWait_args {
 public:

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

  virtual ~ParentService_onewayWait_args() noexcept;

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

  bool operator < (const ParentService_onewayWait_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_onewayWait_pargs {
 public:


  virtual ~ParentService_onewayWait_pargs() noexcept;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

typedef struct _ParentService_exceptionWait_args__isset {
  _ParentService_exceptionWait_args__isset() : message(false) {}
  bool message :1;
} _ParentService_exceptionWait_args__isset;

class ParentService_exceptionWait_args {
 public:

  ParentService_exceptionWait_args(const ParentService_exceptionWait_args&);
  ParentService_exceptionWait_args& operator=(const ParentService_exceptionWait_args&);
  ParentService_exceptionWait_args() : message() {
  }

  virtual ~ParentService_exceptionWait_args() noexcept;
  std::string message;

  _ParentService_exceptionWait_args__isset __isset;

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

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

  bool operator < (const ParentService_exceptionWait_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_exceptionWait_pargs {
 public:


  virtual ~ParentService_exceptionWait_pargs() noexcept;
  const std::string* message;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

typedef struct _ParentService_exceptionWait_result__isset {
  _ParentService_exceptionWait_result__isset() : error(false) {}
  bool error :1;
} _ParentService_exceptionWait_result__isset;

class ParentService_exceptionWait_result {
 public:

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

  virtual ~ParentService_exceptionWait_result() noexcept;
  MyError error;

  _ParentService_exceptionWait_result__isset __isset;

  void __set_error(const MyError& val);

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

  bool operator < (const ParentService_exceptionWait_result & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

typedef struct _ParentService_exceptionWait_presult__isset {
  _ParentService_exceptionWait_presult__isset() : error(false) {}
  bool error :1;
} _ParentService_exceptionWait_presult__isset;

class ParentService_exceptionWait_presult {
 public:


  virtual ~ParentService_exceptionWait_presult() noexcept;
  MyError error;

  _ParentService_exceptionWait_presult__isset __isset;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

typedef struct _ParentService_unexpectedExceptionWait_args__isset {
  _ParentService_unexpectedExceptionWait_args__isset() : message(false) {}
  bool message :1;
} _ParentService_unexpectedExceptionWait_args__isset;

class ParentService_unexpectedExceptionWait_args {
 public:

  ParentService_unexpectedExceptionWait_args(const ParentService_unexpectedExceptionWait_args&);
  ParentService_unexpectedExceptionWait_args& operator=(const ParentService_unexpectedExceptionWait_args&);
  ParentService_unexpectedExceptionWait_args() : message() {
  }

  virtual ~ParentService_unexpectedExceptionWait_args() noexcept;
  std::string message;

  _ParentService_unexpectedExceptionWait_args__isset __isset;

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

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

  bool operator < (const ParentService_unexpectedExceptionWait_args & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_unexpectedExceptionWait_pargs {
 public:


  virtual ~ParentService_unexpectedExceptionWait_pargs() noexcept;
  const std::string* message;

  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_unexpectedExceptionWait_result {
 public:

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

  virtual ~ParentService_unexpectedExceptionWait_result() noexcept;

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

  bool operator < (const ParentService_unexpectedExceptionWait_result & ) const;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};


class ParentService_unexpectedExceptionWait_presult {
 public:


  virtual ~ParentService_unexpectedExceptionWait_presult() noexcept;

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t write(Protocol_* oprot) const;

};

template <class Protocol_>
class ParentServiceClientT : virtual public ParentServiceIf {
 public:
  ParentServiceClientT(std::shared_ptr< Protocol_> prot) {
    setProtocolT(prot);
  }
  ParentServiceClientT(std::shared_ptr< Protocol_> iprot, std::shared_ptr< Protocol_> oprot) {
    setProtocolT(iprot,oprot);
  }
 private:
  void setProtocolT(std::shared_ptr< Protocol_> prot) {
  setProtocolT(prot,prot);
  }
  void setProtocolT(std::shared_ptr< Protocol_> iprot, std::shared_ptr< Protocol_> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return this->piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return this->poprot_;
  }
  int32_t incrementGeneration();
  void send_incrementGeneration();
  int32_t recv_incrementGeneration();
  int32_t getGeneration();
  void send_getGeneration();
  int32_t recv_getGeneration();
  void addString(const std::string& s);
  void send_addString(const std::string& s);
  void recv_addString();
  void getStrings(std::vector<std::string> & _return);
  void send_getStrings();
  void recv_getStrings(std::vector<std::string> & _return);
  void getDataWait(std::string& _return, const int32_t length);
  void send_getDataWait(const int32_t length);
  void recv_getDataWait(std::string& _return);
  void onewayWait();
  void send_onewayWait();
  void exceptionWait(const std::string& message);
  void send_exceptionWait(const std::string& message);
  void recv_exceptionWait();
  void unexpectedExceptionWait(const std::string& message);
  void send_unexpectedExceptionWait(const std::string& message);
  void recv_unexpectedExceptionWait();
 protected:
  std::shared_ptr< Protocol_> piprot_;
  std::shared_ptr< Protocol_> poprot_;
  Protocol_* iprot_;
  Protocol_* oprot_;
};

typedef ParentServiceClientT< ::apache::thrift::protocol::TProtocol> ParentServiceClient;

template <class Protocol_>
class ParentServiceProcessorT : public ::apache::thrift::TDispatchProcessorT<Protocol_> {
 protected:
  ::std::shared_ptr<ParentServiceIf> iface_;
  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
  virtual bool dispatchCallTemplated(Protocol_* iprot, Protocol_* oprot, const std::string& fname, int32_t seqid, void* callContext);
 private:
  typedef  void (ParentServiceProcessorT::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef void (ParentServiceProcessorT::*SpecializedProcessFunction)(int32_t, Protocol_*, Protocol_*, void*);
  struct ProcessFunctions {
    ProcessFunction generic;
    SpecializedProcessFunction specialized;
    ProcessFunctions(ProcessFunction g, SpecializedProcessFunction s) :
      generic(g),
      specialized(s) {}
    ProcessFunctions() : generic(NULL), specialized(NULL) {}
  };
  typedef std::map<std::string, ProcessFunctions> ProcessMap;
  ProcessMap processMap_;
  void process_incrementGeneration(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_incrementGeneration(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
  void process_getGeneration(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getGeneration(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
  void process_addString(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_addString(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
  void process_getStrings(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getStrings(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
  void process_getDataWait(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getDataWait(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
  void process_onewayWait(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_onewayWait(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
  void process_exceptionWait(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_exceptionWait(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
  void process_unexpectedExceptionWait(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_unexpectedExceptionWait(int32_t seqid, Protocol_* iprot, Protocol_* oprot, void* callContext);
 public:
  ParentServiceProcessorT(::std::shared_ptr<ParentServiceIf> iface) :
    iface_(iface) {
    processMap_["incrementGeneration"] = ProcessFunctions(
      &ParentServiceProcessorT::process_incrementGeneration,
      &ParentServiceProcessorT::process_incrementGeneration);
    processMap_["getGeneration"] = ProcessFunctions(
      &ParentServiceProcessorT::process_getGeneration,
      &ParentServiceProcessorT::process_getGeneration);
    processMap_["addString"] = ProcessFunctions(
      &ParentServiceProcessorT::process_addString,
      &ParentServiceProcessorT::process_addString);
    processMap_["getStrings"] = ProcessFunctions(
      &ParentServiceProcessorT::process_getStrings,
      &ParentServiceProcessorT::process_getStrings);
    processMap_["getDataWait"] = ProcessFunctions(
      &ParentServiceProcessorT::process_getDataWait,
      &ParentServiceProcessorT::process_getDataWait);
    processMap_["onewayWait"] = ProcessFunctions(
      &ParentServiceProcessorT::process_onewayWait,
      &ParentServiceProcessorT::process_onewayWait);
    processMap_["exceptionWait"] = ProcessFunctions(
      &ParentServiceProcessorT::process_exceptionWait,
      &ParentServiceProcessorT::process_exceptionWait);
    processMap_["unexpectedExceptionWait"] = ProcessFunctions(
      &ParentServiceProcessorT::process_unexpectedExceptionWait,
      &ParentServiceProcessorT::process_unexpectedExceptionWait);
  }

  virtual ~ParentServiceProcessorT() {}
};

typedef ParentServiceProcessorT< ::apache::thrift::protocol::TDummyProtocol > ParentServiceProcessor;

template <class Protocol_>
class ParentServiceProcessorFactoryT : public ::apache::thrift::TProcessorFactory {
 public:
  ParentServiceProcessorFactoryT(const ::std::shared_ptr< ParentServiceIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

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

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

typedef ParentServiceProcessorFactoryT< ::apache::thrift::protocol::TDummyProtocol > ParentServiceProcessorFactory;

class ParentServiceMultiface : virtual public ParentServiceIf {
 public:
  ParentServiceMultiface(std::vector<std::shared_ptr<ParentServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~ParentServiceMultiface() {}
 protected:
  std::vector<std::shared_ptr<ParentServiceIf> > ifaces_;
  ParentServiceMultiface() {}
  void add(::std::shared_ptr<ParentServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  int32_t incrementGeneration() {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->incrementGeneration();
    }
    return ifaces_[i]->incrementGeneration();
  }

  int32_t getGeneration() {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getGeneration();
    }
    return ifaces_[i]->getGeneration();
  }

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

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

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

  void onewayWait() {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->onewayWait();
    }
    ifaces_[i]->onewayWait();
  }

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

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

};

// 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
template <class Protocol_>
class ParentServiceConcurrentClientT : virtual public ParentServiceIf {
 public:
  ParentServiceConcurrentClientT(std::shared_ptr< Protocol_> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocolT(prot);
  }
  ParentServiceConcurrentClientT(std::shared_ptr< Protocol_> iprot, std::shared_ptr< Protocol_> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocolT(iprot,oprot);
  }
 private:
  void setProtocolT(std::shared_ptr< Protocol_> prot) {
  setProtocolT(prot,prot);
  }
  void setProtocolT(std::shared_ptr< Protocol_> iprot, std::shared_ptr< Protocol_> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return this->piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return this->poprot_;
  }
  int32_t incrementGeneration();
  int32_t send_incrementGeneration();
  int32_t recv_incrementGeneration(const int32_t seqid);
  int32_t getGeneration();
  int32_t send_getGeneration();
  int32_t recv_getGeneration(const int32_t seqid);
  void addString(const std::string& s);
  int32_t send_addString(const std::string& s);
  void recv_addString(const int32_t seqid);
  void getStrings(std::vector<std::string> & _return);
  int32_t send_getStrings();
  void recv_getStrings(std::vector<std::string> & _return, const int32_t seqid);
  void getDataWait(std::string& _return, const int32_t length);
  int32_t send_getDataWait(const int32_t length);
  void recv_getDataWait(std::string& _return, const int32_t seqid);
  void onewayWait();
  void send_onewayWait();
  void exceptionWait(const std::string& message);
  int32_t send_exceptionWait(const std::string& message);
  void recv_exceptionWait(const int32_t seqid);
  void unexpectedExceptionWait(const std::string& message);
  int32_t send_unexpectedExceptionWait(const std::string& message);
  void recv_unexpectedExceptionWait(const int32_t seqid);
 protected:
  std::shared_ptr< Protocol_> piprot_;
  std::shared_ptr< Protocol_> poprot_;
  Protocol_* iprot_;
  Protocol_* oprot_;
  std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync_;
};

typedef ParentServiceConcurrentClientT< ::apache::thrift::protocol::TProtocol> ParentServiceConcurrentClient;

template <class Protocol_>
class ParentServiceCobClientT;

template <class Protocol_>
class ParentServiceCobClIfT {
 public:
  virtual ~ParentServiceCobClIfT() {}
  virtual void incrementGeneration(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob) = 0;
  virtual void getGeneration(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob) = 0;
  virtual void addString(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const std::string& s) = 0;
  virtual void getStrings(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob) = 0;
  virtual void getDataWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const int32_t length) = 0;
  virtual void onewayWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob) = 0;
  virtual void exceptionWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const std::string& message) = 0;
  virtual void unexpectedExceptionWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const std::string& message) = 0;
};

typedef ParentServiceCobClIfT< ::apache::thrift::protocol::TProtocol> ParentServiceCobClIf;

class ParentServiceCobSvIf {
 public:
  virtual ~ParentServiceCobSvIf() {}
  virtual void incrementGeneration(::std::function<void(int32_t const& _return)> cob) = 0;
  virtual void getGeneration(::std::function<void(int32_t const& _return)> cob) = 0;
  virtual void addString(::std::function<void()> cob, const std::string& s) = 0;
  virtual void getStrings(::std::function<void(std::vector<std::string>  const& _return)> cob) = 0;
  virtual void getDataWait(::std::function<void(std::string const& _return)> cob, const int32_t length) = 0;
  virtual void onewayWait(::std::function<void()> cob) = 0;
  virtual void exceptionWait(::std::function<void()> cob, ::std::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */, const std::string& message) = 0;
  virtual void unexpectedExceptionWait(::std::function<void()> cob, const std::string& message) = 0;
};

class ParentServiceCobSvIfFactory {
 public:
  typedef ParentServiceCobSvIf Handler;

  virtual ~ParentServiceCobSvIfFactory() {}

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

class ParentServiceCobSvIfSingletonFactory : virtual public ParentServiceCobSvIfFactory {
 public:
  ParentServiceCobSvIfSingletonFactory(const ::std::shared_ptr<ParentServiceCobSvIf>& iface) : iface_(iface) {}
  virtual ~ParentServiceCobSvIfSingletonFactory() {}

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

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

class ParentServiceCobSvNull : virtual public ParentServiceCobSvIf {
 public:
  virtual ~ParentServiceCobSvNull() {}
  void incrementGeneration(::std::function<void(int32_t const& _return)> cob) {
    int32_t _return = 0;
    return cob(_return);
  }
  void getGeneration(::std::function<void(int32_t const& _return)> cob) {
    int32_t _return = 0;
    return cob(_return);
  }
  void addString(::std::function<void()> cob, const std::string& /* s */) {
    return cob();
  }
  void getStrings(::std::function<void(std::vector<std::string>  const& _return)> cob) {
    std::vector<std::string>  _return;
    return cob(_return);
  }
  void getDataWait(::std::function<void(std::string const& _return)> cob, const int32_t /* length */) {
    std::string _return;
    return cob(_return);
  }
  void onewayWait(::std::function<void()> cob) {
    return cob();
  }
  void exceptionWait(::std::function<void()> cob, ::std::function<void(::apache::thrift::TDelayedException* _throw)> /* exn_cob */, const std::string& /* message */) {
    return cob();
  }
  void unexpectedExceptionWait(::std::function<void()> cob, const std::string& /* message */) {
    return cob();
  }
};

template <class Protocol_>
class ParentServiceCobClientT : virtual public ParentServiceCobClIfT<Protocol_> {
 public:
  ParentServiceCobClientT(std::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel, ::apache::thrift::protocol::TProtocolFactory* protocolFactory) :
    channel_(channel),
    itrans_(new ::apache::thrift::transport::TMemoryBuffer()),
    otrans_(new ::apache::thrift::transport::TMemoryBuffer()),
    piprot_(::std::dynamic_pointer_cast<Protocol_>(protocolFactory->getProtocol(itrans_))),
    poprot_(::std::dynamic_pointer_cast<Protocol_>(protocolFactory->getProtocol(otrans_))) {
    if (!piprot_ || !poprot_) {
      throw ::apache::thrift::TException("TProtocolFactory returned unexpected protocol type in ParentServiceCobClientT constructor");
    }
    iprot_ = piprot_.get();
    oprot_ = poprot_.get();
  }
  ::std::shared_ptr< ::apache::thrift::async::TAsyncChannel> getChannel() {
    return this->channel_;
  }
  virtual void completed__(bool /* success */) {}
  void incrementGeneration(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob);
  void send_incrementGeneration();
  int32_t recv_incrementGeneration();
  void getGeneration(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob);
  void send_getGeneration();
  int32_t recv_getGeneration();
  void addString(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const std::string& s);
  void send_addString(const std::string& s);
  void recv_addString();
  void getStrings(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob);
  void send_getStrings();
  void recv_getStrings(std::vector<std::string> & _return);
  void getDataWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const int32_t length);
  void send_getDataWait(const int32_t length);
  void recv_getDataWait(std::string& _return);
  void onewayWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob);
  void send_onewayWait();
  void exceptionWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const std::string& message);
  void send_exceptionWait(const std::string& message);
  void recv_exceptionWait();
  void unexpectedExceptionWait(::std::function<void(ParentServiceCobClientT<Protocol_>* client)> cob, const std::string& message);
  void send_unexpectedExceptionWait(const std::string& message);
  void recv_unexpectedExceptionWait();
 protected:
  ::std::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel_;
  ::std::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> itrans_;
  ::std::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> otrans_;
  std::shared_ptr< Protocol_> piprot_;
  std::shared_ptr< Protocol_> poprot_;
  Protocol_* iprot_;
  Protocol_* oprot_;
};

typedef ParentServiceCobClientT< ::apache::thrift::protocol::TProtocol> ParentServiceCobClient;

template <class Protocol_>
class ParentServiceAsyncProcessorT : public ::apache::thrift::async::TAsyncDispatchProcessorT<Protocol_> {
 protected:
  ::std::shared_ptr<ParentServiceCobSvIf> iface_;
  virtual void dispatchCall(::std::function<void(bool ok)> cob, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid);
  virtual void dispatchCallTemplated(::std::function<void(bool ok)> cob, Protocol_* iprot, Protocol_* oprot, const std::string& fname, int32_t seqid);
 private:
  typedef  void (ParentServiceAsyncProcessorT::*ProcessFunction)(::std::function<void(bool ok)>, int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*);
  typedef void (ParentServiceAsyncProcessorT::*SpecializedProcessFunction)(::std::function<void(bool ok)>, int32_t, Protocol_*, Protocol_*);
  struct ProcessFunctions {
    ProcessFunction generic;
    SpecializedProcessFunction specialized;
    ProcessFunctions(ProcessFunction g, SpecializedProcessFunction s) :
      generic(g),
      specialized(s) {}
    ProcessFunctions() : generic(NULL), specialized(NULL) {}
  };
  typedef std::map<std::string, ProcessFunctions> ProcessMap;
  ProcessMap processMap_;
  void process_incrementGeneration(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_incrementGeneration(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_incrementGeneration(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, const int32_t& _return);
  void return_incrementGeneration(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, const int32_t& _return);
  void throw_incrementGeneration(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_incrementGeneration(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void process_getGeneration(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_getGeneration(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_getGeneration(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, const int32_t& _return);
  void return_getGeneration(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, const int32_t& _return);
  void throw_getGeneration(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_getGeneration(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void process_addString(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_addString(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_addString(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx);
  void return_addString(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx);
  void throw_addString(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_addString(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void process_getStrings(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_getStrings(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_getStrings(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, const std::vector<std::string> & _return);
  void return_getStrings(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, const std::vector<std::string> & _return);
  void throw_getStrings(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_getStrings(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void process_getDataWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_getDataWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_getDataWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, const std::string& _return);
  void return_getDataWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, const std::string& _return);
  void throw_getDataWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_getDataWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void process_onewayWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_onewayWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_onewayWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx);
  void return_onewayWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx);
  void throw_onewayWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_onewayWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void process_exceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_exceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_exceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx);
  void return_exceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx);
  void throw_exceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_exceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void process_unexpectedExceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_unexpectedExceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* iprot, Protocol_* oprot);
  void return_unexpectedExceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx);
  void return_unexpectedExceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx);
  void throw_unexpectedExceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, ::apache::thrift::protocol::TProtocol* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
  void throw_unexpectedExceptionWait(::std::function<void(bool ok)> cob, int32_t seqid, Protocol_* oprot, void* ctx, ::apache::thrift::TDelayedException* _throw);
 public:
  ParentServiceAsyncProcessorT(::std::shared_ptr<ParentServiceCobSvIf> iface) :
    iface_(iface) {
    processMap_["incrementGeneration"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_incrementGeneration,
      &ParentServiceAsyncProcessorT::process_incrementGeneration);
    processMap_["getGeneration"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_getGeneration,
      &ParentServiceAsyncProcessorT::process_getGeneration);
    processMap_["addString"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_addString,
      &ParentServiceAsyncProcessorT::process_addString);
    processMap_["getStrings"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_getStrings,
      &ParentServiceAsyncProcessorT::process_getStrings);
    processMap_["getDataWait"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_getDataWait,
      &ParentServiceAsyncProcessorT::process_getDataWait);
    processMap_["onewayWait"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_onewayWait,
      &ParentServiceAsyncProcessorT::process_onewayWait);
    processMap_["exceptionWait"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_exceptionWait,
      &ParentServiceAsyncProcessorT::process_exceptionWait);
    processMap_["unexpectedExceptionWait"] = ProcessFunctions(
      &ParentServiceAsyncProcessorT::process_unexpectedExceptionWait,
      &ParentServiceAsyncProcessorT::process_unexpectedExceptionWait);
  }

  virtual ~ParentServiceAsyncProcessorT() {}
};

typedef ParentServiceAsyncProcessorT< ::apache::thrift::protocol::TDummyProtocol > ParentServiceAsyncProcessor;

template <class Protocol_>
class ParentServiceAsyncProcessorFactoryT : public ::apache::thrift::async::TAsyncProcessorFactory {
 public:
  ParentServiceAsyncProcessorFactoryT(const ::std::shared_ptr< ParentServiceCobSvIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

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

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

typedef ParentServiceAsyncProcessorFactoryT< ::apache::thrift::protocol::TDummyProtocol > ParentServiceAsyncProcessorFactory;

#ifdef _MSC_VER
  #pragma warning( pop )
#endif

}}} // namespace

#include "ParentService.tcc"
#include "proc_types.tcc"

#endif
