/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
#ifndef Calculator_H
#define Calculator_H

#include <TProcessor.h>
#include "tutorial_types.h"
#include "SharedService.h"

namespace tutorial { 

class CalculatorIf : virtual public shared::SharedServiceIf {
 public: 
  virtual ~CalculatorIf() {}
  virtual void ping() = 0;
  virtual int32_t add(const int32_t num1, const int32_t num2) = 0;
  virtual int32_t calculate(const int32_t logid, const Work& w) = 0;
  virtual void zip() = 0;
}; 

class CalculatorNull : virtual public CalculatorIf , virtual public shared::SharedServiceNull {
 public: 
  virtual ~CalculatorNull() {}
  void ping() {
    return;
  }
  int32_t add(const int32_t num1, const int32_t num2) {
    int32_t _return = 0;
    return _return;
  }
  int32_t calculate(const int32_t logid, const Work& w) {
    int32_t _return = 0;
    return _return;
  }
  void zip() {
    return;
  }
}; 

class Calculator_ping_args {
 public:

  Calculator_ping_args() {
  } 

  virtual ~Calculator_ping_args() throw() {}


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

};

class Calculator_ping_pargs {
 public:


  virtual ~Calculator_ping_pargs() throw() {}


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

};

class Calculator_ping_result {
 public:

  Calculator_ping_result() {
  } 

  virtual ~Calculator_ping_result() throw() {}


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

};

class Calculator_ping_presult {
 public:


  virtual ~Calculator_ping_presult() throw() {}


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

};

class Calculator_add_args {
 public:

  Calculator_add_args() : num1(0), num2(0) {
  } 

  virtual ~Calculator_add_args() throw() {}

  int32_t num1;
  int32_t num2;

  struct __isset {
    __isset() : num1(false), num2(false) {}
    bool num1;
    bool num2;
  } __isset;

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

};

class Calculator_add_pargs {
 public:


  virtual ~Calculator_add_pargs() throw() {}

  const int32_t* num1;
  const int32_t* num2;

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

};

class Calculator_add_result {
 public:

  Calculator_add_result() : success(0) {
  } 

  virtual ~Calculator_add_result() throw() {}

  int32_t success;

  struct __isset {
    __isset() : success(false) {}
    bool success;
  } __isset;

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

};

class Calculator_add_presult {
 public:


  virtual ~Calculator_add_presult() throw() {}

  int32_t* success;

  struct __isset {
    __isset() : success(false) {}
    bool success;
  } __isset;

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

};

class Calculator_calculate_args {
 public:

  Calculator_calculate_args() : logid(0) {
  } 

  virtual ~Calculator_calculate_args() throw() {}

  int32_t logid;
  Work w;

  struct __isset {
    __isset() : logid(false), w(false) {}
    bool logid;
    bool w;
  } __isset;

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

};

class Calculator_calculate_pargs {
 public:


  virtual ~Calculator_calculate_pargs() throw() {}

  const int32_t* logid;
  const Work* w;

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

};

class Calculator_calculate_result {
 public:

  Calculator_calculate_result() : success(0) {
  } 

  virtual ~Calculator_calculate_result() throw() {}

  int32_t success;
  InvalidOperation ouch;

  struct __isset {
    __isset() : success(false), ouch(false) {}
    bool success;
    bool ouch;
  } __isset;

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

};

class Calculator_calculate_presult {
 public:


  virtual ~Calculator_calculate_presult() throw() {}

  int32_t* success;
  InvalidOperation ouch;

  struct __isset {
    __isset() : success(false), ouch(false) {}
    bool success;
    bool ouch;
  } __isset;

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

};

class Calculator_zip_args {
 public:

  Calculator_zip_args() {
  } 

  virtual ~Calculator_zip_args() throw() {}


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

};

class Calculator_zip_pargs {
 public:


  virtual ~Calculator_zip_pargs() throw() {}


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

};

class CalculatorClient : virtual public CalculatorIf, public shared::SharedServiceClient {
 public:
  CalculatorClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> prot) : 
    shared::SharedServiceClient(prot, prot) {}
  CalculatorClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> iprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> oprot) : 
    shared::SharedServiceClient(iprot, oprot) {}
  void ping();
  void send_ping();
  void recv_ping();
  int32_t add(const int32_t num1, const int32_t num2);
  void send_add(const int32_t num1, const int32_t num2);
  int32_t recv_add();
  int32_t calculate(const int32_t logid, const Work& w);
  void send_calculate(const int32_t logid, const Work& w);
  int32_t recv_calculate();
  void zip();
  void send_zip();
};

class CalculatorProcessor : virtual public facebook::thrift::TProcessor, public shared::SharedServiceProcessor {
 protected:
  boost::shared_ptr<CalculatorIf> iface_;
  virtual bool process_fn(facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
 private:
  std::map<std::string, void (CalculatorProcessor::*)(int32_t, facebook::thrift::protocol::TProtocol*, facebook::thrift::protocol::TProtocol*)> processMap_;
  void process_ping(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_add(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_calculate(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_zip(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
 public: 
  CalculatorProcessor(boost::shared_ptr<CalculatorIf> iface) :
    shared::SharedServiceProcessor(iface),
    iface_(iface) {
    processMap_["ping"] = &CalculatorProcessor::process_ping;
    processMap_["add"] = &CalculatorProcessor::process_add;
    processMap_["calculate"] = &CalculatorProcessor::process_calculate;
    processMap_["zip"] = &CalculatorProcessor::process_zip;
  }

  virtual bool process(boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot);
  virtual ~CalculatorProcessor() {}
};

class CalculatorMultiface : virtual public CalculatorIf, public shared::SharedServiceMultiface {
 public: 
  CalculatorMultiface(std::vector<boost::shared_ptr<CalculatorIf> >& ifaces) : ifaces_(ifaces) {
    std::vector<boost::shared_ptr<CalculatorIf> >::iterator iter;
    for (iter = ifaces.begin(); iter != ifaces.end(); ++iter) {
      shared::SharedServiceMultiface::add(*iter);
    }
  }
  virtual ~CalculatorMultiface() {}
 protected:
  std::vector<boost::shared_ptr<CalculatorIf> > ifaces_;
  CalculatorMultiface() {}
  void add(boost::shared_ptr<CalculatorIf> iface) { 
    shared::SharedServiceMultiface::add(iface);
    ifaces_.push_back(iface);
  }
 public:
  void ping() {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->ping();
    }
  }

  int32_t add(const int32_t num1, const int32_t num2) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->add(num1, num2);
      } else {
        ifaces_[i]->add(num1, num2);
      }
    }
  }

  int32_t calculate(const int32_t logid, const Work& w) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->calculate(logid, w);
      } else {
        ifaces_[i]->calculate(logid, w);
      }
    }
  }

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

};

} // namespace

#endif