MemoryHierarchy.h

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

#include <TProcessor.h>
#include "simple_types.h"

namespace simple {

class MemoryHierarchyIf {
 public:
  virtual ~MemoryHierarchyIf() {}
  virtual void step() = 0;
  virtual void operate(const Work& w) = 0;
};

class MemoryHierarchyNull : virtual public MemoryHierarchyIf {
 public:
  virtual ~MemoryHierarchyNull() {}
  void step() {
    return;
  }
  void operate(const Work& /* w */) {
    return;
  }
};

class MemoryHierarchy_step_args {
 public:

  MemoryHierarchy_step_args() {
  }

  virtual ~MemoryHierarchy_step_args() throw() {}


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

  bool operator < (const MemoryHierarchy_step_args & ) const;

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

};

class MemoryHierarchy_step_pargs {
 public:


  virtual ~MemoryHierarchy_step_pargs() throw() {}


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

};

class MemoryHierarchy_step_result {
 public:

  MemoryHierarchy_step_result() {
  }

  virtual ~MemoryHierarchy_step_result() throw() {}


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

  bool operator < (const MemoryHierarchy_step_result & ) const;

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

};

class MemoryHierarchy_step_presult {
 public:


  virtual ~MemoryHierarchy_step_presult() throw() {}


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

};

class MemoryHierarchy_operate_args {
 public:

  MemoryHierarchy_operate_args() {
  }

  virtual ~MemoryHierarchy_operate_args() throw() {}

  Work w;

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

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

  bool operator < (const MemoryHierarchy_operate_args & ) const;

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

};

class MemoryHierarchy_operate_pargs {
 public:


  virtual ~MemoryHierarchy_operate_pargs() throw() {}

  const Work* w;

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

};

class MemoryHierarchy_operate_result {
 public:

  MemoryHierarchy_operate_result() {
  }

  virtual ~MemoryHierarchy_operate_result() throw() {}


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

  bool operator < (const MemoryHierarchy_operate_result & ) const;

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

};

class MemoryHierarchy_operate_presult {
 public:


  virtual ~MemoryHierarchy_operate_presult() throw() {}


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

};

class MemoryHierarchyClient : virtual public MemoryHierarchyIf {
 public:
  MemoryHierarchyClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> prot) :
    piprot_(prot),
    poprot_(prot) {
    iprot_ = prot.get();
    oprot_ = prot.get();
  }
  MemoryHierarchyClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> iprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> oprot) :
    piprot_(iprot),
    poprot_(oprot) {
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void step();
  void send_step();
  void recv_step();
  void operate(const Work& w);
  void send_operate(const Work& w);
  void recv_operate();
 protected:
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot_;
  facebook::thrift::protocol::TProtocol* iprot_;
  facebook::thrift::protocol::TProtocol* oprot_;
};

class MemoryHierarchyProcessor : virtual public facebook::thrift::TProcessor {
 protected:
  boost::shared_ptr<MemoryHierarchyIf> 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 (MemoryHierarchyProcessor::*)(int32_t, facebook::thrift::protocol::TProtocol*, facebook::thrift::protocol::TProtocol*)> processMap_;
  void process_step(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_operate(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
 public:
  MemoryHierarchyProcessor(boost::shared_ptr<MemoryHierarchyIf> iface) :
    iface_(iface) {
    processMap_["step"] = &MemoryHierarchyProcessor::process_step;
    processMap_["operate"] = &MemoryHierarchyProcessor::process_operate;
  }

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

class MemoryHierarchyMultiface : virtual public MemoryHierarchyIf {
 public:
  MemoryHierarchyMultiface(std::vector<boost::shared_ptr<MemoryHierarchyIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~MemoryHierarchyMultiface() {}
 protected:
  std::vector<boost::shared_ptr<MemoryHierarchyIf> > ifaces_;
  MemoryHierarchyMultiface() {}
  void add(boost::shared_ptr<MemoryHierarchyIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void step() {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->step();
    }
  }

  void operate(const Work& w) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->operate(w);
    }
  }

};

} // namespace

#endif