MyService.h

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

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

namespace mp2 {

class MyServiceIf {
 public:
  virtual ~MyServiceIf() {}
  virtual void get_predecessor(finger_entry& _return) = 0;
  virtual void get_successor(finger_entry& _return) = 0;
  virtual void find_successor(finger_entry& _return, const int32_t id) = 0;
  virtual void find_predecessor(finger_entry& _return, const int32_t id) = 0;
  virtual void closest_preceding_finger(finger_entry& _return, const int32_t id) = 0;
  virtual void notify(const finger_entry& n) = 0;
  virtual void gateway_add_file_self(std::string& _return, const std::string& name, const std::string& content) = 0;
  virtual void gateway_add_file_other(std::string& _return, const std::string& name, const std::string& content) = 0;
  virtual void gateway_del_file_self(std::string& _return, const std::string& name) = 0;
  virtual void gateway_del_file_other(std::string& _return, const std::string& name) = 0;
  virtual void gateway_get_file_self(std::string& _return, const std::string& name) = 0;
  virtual void gateway_get_file_other(std::string& _return, const std::string& name) = 0;
  virtual void gateway_get_self_table(std::string& _return) = 0;
  virtual void gateway_get_other_table(std::string& _return, const int32_t id) = 0;
};

class MyServiceIfFactory {
 public:
  typedef MyServiceIf Handler;

  virtual ~MyServiceIfFactory() {}

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

class MyServiceIfSingletonFactory : virtual public MyServiceIfFactory {
 public:
  MyServiceIfSingletonFactory(const boost::shared_ptr<MyServiceIf>& iface) : iface_(iface) {}
  virtual ~MyServiceIfSingletonFactory() {}

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

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

class MyServiceNull : virtual public MyServiceIf {
 public:
  virtual ~MyServiceNull() {}
  void get_predecessor(finger_entry& /* _return */) {
    return;
  }
  void get_successor(finger_entry& /* _return */) {
    return;
  }
  void find_successor(finger_entry& /* _return */, const int32_t /* id */) {
    return;
  }
  void find_predecessor(finger_entry& /* _return */, const int32_t /* id */) {
    return;
  }
  void closest_preceding_finger(finger_entry& /* _return */, const int32_t /* id */) {
    return;
  }
  void notify(const finger_entry& /* n */) {
    return;
  }
  void gateway_add_file_self(std::string& /* _return */, const std::string& /* name */, const std::string& /* content */) {
    return;
  }
  void gateway_add_file_other(std::string& /* _return */, const std::string& /* name */, const std::string& /* content */) {
    return;
  }
  void gateway_del_file_self(std::string& /* _return */, const std::string& /* name */) {
    return;
  }
  void gateway_del_file_other(std::string& /* _return */, const std::string& /* name */) {
    return;
  }
  void gateway_get_file_self(std::string& /* _return */, const std::string& /* name */) {
    return;
  }
  void gateway_get_file_other(std::string& /* _return */, const std::string& /* name */) {
    return;
  }
  void gateway_get_self_table(std::string& /* _return */) {
    return;
  }
  void gateway_get_other_table(std::string& /* _return */, const int32_t /* id */) {
    return;
  }
};


class MyService_get_predecessor_args {
 public:

  MyService_get_predecessor_args() {
  }

  virtual ~MyService_get_predecessor_args() throw() {}


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

  bool operator < (const MyService_get_predecessor_args & ) const;

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

};


class MyService_get_predecessor_pargs {
 public:


  virtual ~MyService_get_predecessor_pargs() throw() {}


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

};

typedef struct _MyService_get_predecessor_result__isset {
  _MyService_get_predecessor_result__isset() : success(false) {}
  bool success;
} _MyService_get_predecessor_result__isset;

class MyService_get_predecessor_result {
 public:

  MyService_get_predecessor_result() {
  }

  virtual ~MyService_get_predecessor_result() throw() {}

  finger_entry success;

  _MyService_get_predecessor_result__isset __isset;

  void __set_success(const finger_entry& val) {
    success = val;
  }

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

  bool operator < (const MyService_get_predecessor_result & ) const;

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

};

typedef struct _MyService_get_predecessor_presult__isset {
  _MyService_get_predecessor_presult__isset() : success(false) {}
  bool success;
} _MyService_get_predecessor_presult__isset;

class MyService_get_predecessor_presult {
 public:


  virtual ~MyService_get_predecessor_presult() throw() {}

  finger_entry* success;

  _MyService_get_predecessor_presult__isset __isset;

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

};


class MyService_get_successor_args {
 public:

  MyService_get_successor_args() {
  }

  virtual ~MyService_get_successor_args() throw() {}


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

  bool operator < (const MyService_get_successor_args & ) const;

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

};


class MyService_get_successor_pargs {
 public:


  virtual ~MyService_get_successor_pargs() throw() {}


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

};

typedef struct _MyService_get_successor_result__isset {
  _MyService_get_successor_result__isset() : success(false) {}
  bool success;
} _MyService_get_successor_result__isset;

class MyService_get_successor_result {
 public:

  MyService_get_successor_result() {
  }

  virtual ~MyService_get_successor_result() throw() {}

  finger_entry success;

  _MyService_get_successor_result__isset __isset;

  void __set_success(const finger_entry& val) {
    success = val;
  }

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

  bool operator < (const MyService_get_successor_result & ) const;

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

};

typedef struct _MyService_get_successor_presult__isset {
  _MyService_get_successor_presult__isset() : success(false) {}
  bool success;
} _MyService_get_successor_presult__isset;

class MyService_get_successor_presult {
 public:


  virtual ~MyService_get_successor_presult() throw() {}

  finger_entry* success;

  _MyService_get_successor_presult__isset __isset;

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

};

typedef struct _MyService_find_successor_args__isset {
  _MyService_find_successor_args__isset() : id(false) {}
  bool id;
} _MyService_find_successor_args__isset;

class MyService_find_successor_args {
 public:

  MyService_find_successor_args() : id(0) {
  }

  virtual ~MyService_find_successor_args() throw() {}

  int32_t id;

  _MyService_find_successor_args__isset __isset;

  void __set_id(const int32_t val) {
    id = val;
  }

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

  bool operator < (const MyService_find_successor_args & ) const;

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

};


class MyService_find_successor_pargs {
 public:


  virtual ~MyService_find_successor_pargs() throw() {}

  const int32_t* id;

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

};

typedef struct _MyService_find_successor_result__isset {
  _MyService_find_successor_result__isset() : success(false) {}
  bool success;
} _MyService_find_successor_result__isset;

class MyService_find_successor_result {
 public:

  MyService_find_successor_result() {
  }

  virtual ~MyService_find_successor_result() throw() {}

  finger_entry success;

  _MyService_find_successor_result__isset __isset;

  void __set_success(const finger_entry& val) {
    success = val;
  }

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

  bool operator < (const MyService_find_successor_result & ) const;

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

};

typedef struct _MyService_find_successor_presult__isset {
  _MyService_find_successor_presult__isset() : success(false) {}
  bool success;
} _MyService_find_successor_presult__isset;

class MyService_find_successor_presult {
 public:


  virtual ~MyService_find_successor_presult() throw() {}

  finger_entry* success;

  _MyService_find_successor_presult__isset __isset;

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

};

typedef struct _MyService_find_predecessor_args__isset {
  _MyService_find_predecessor_args__isset() : id(false) {}
  bool id;
} _MyService_find_predecessor_args__isset;

class MyService_find_predecessor_args {
 public:

  MyService_find_predecessor_args() : id(0) {
  }

  virtual ~MyService_find_predecessor_args() throw() {}

  int32_t id;

  _MyService_find_predecessor_args__isset __isset;

  void __set_id(const int32_t val) {
    id = val;
  }

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

  bool operator < (const MyService_find_predecessor_args & ) const;

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

};


class MyService_find_predecessor_pargs {
 public:


  virtual ~MyService_find_predecessor_pargs() throw() {}

  const int32_t* id;

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

};

typedef struct _MyService_find_predecessor_result__isset {
  _MyService_find_predecessor_result__isset() : success(false) {}
  bool success;
} _MyService_find_predecessor_result__isset;

class MyService_find_predecessor_result {
 public:

  MyService_find_predecessor_result() {
  }

  virtual ~MyService_find_predecessor_result() throw() {}

  finger_entry success;

  _MyService_find_predecessor_result__isset __isset;

  void __set_success(const finger_entry& val) {
    success = val;
  }

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

  bool operator < (const MyService_find_predecessor_result & ) const;

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

};

typedef struct _MyService_find_predecessor_presult__isset {
  _MyService_find_predecessor_presult__isset() : success(false) {}
  bool success;
} _MyService_find_predecessor_presult__isset;

class MyService_find_predecessor_presult {
 public:


  virtual ~MyService_find_predecessor_presult() throw() {}

  finger_entry* success;

  _MyService_find_predecessor_presult__isset __isset;

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

};

typedef struct _MyService_closest_preceding_finger_args__isset {
  _MyService_closest_preceding_finger_args__isset() : id(false) {}
  bool id;
} _MyService_closest_preceding_finger_args__isset;

class MyService_closest_preceding_finger_args {
 public:

  MyService_closest_preceding_finger_args() : id(0) {
  }

  virtual ~MyService_closest_preceding_finger_args() throw() {}

  int32_t id;

  _MyService_closest_preceding_finger_args__isset __isset;

  void __set_id(const int32_t val) {
    id = val;
  }

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

  bool operator < (const MyService_closest_preceding_finger_args & ) const;

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

};


class MyService_closest_preceding_finger_pargs {
 public:


  virtual ~MyService_closest_preceding_finger_pargs() throw() {}

  const int32_t* id;

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

};

typedef struct _MyService_closest_preceding_finger_result__isset {
  _MyService_closest_preceding_finger_result__isset() : success(false) {}
  bool success;
} _MyService_closest_preceding_finger_result__isset;

class MyService_closest_preceding_finger_result {
 public:

  MyService_closest_preceding_finger_result() {
  }

  virtual ~MyService_closest_preceding_finger_result() throw() {}

  finger_entry success;

  _MyService_closest_preceding_finger_result__isset __isset;

  void __set_success(const finger_entry& val) {
    success = val;
  }

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

  bool operator < (const MyService_closest_preceding_finger_result & ) const;

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

};

typedef struct _MyService_closest_preceding_finger_presult__isset {
  _MyService_closest_preceding_finger_presult__isset() : success(false) {}
  bool success;
} _MyService_closest_preceding_finger_presult__isset;

class MyService_closest_preceding_finger_presult {
 public:


  virtual ~MyService_closest_preceding_finger_presult() throw() {}

  finger_entry* success;

  _MyService_closest_preceding_finger_presult__isset __isset;

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

};

typedef struct _MyService_notify_args__isset {
  _MyService_notify_args__isset() : n(false) {}
  bool n;
} _MyService_notify_args__isset;

class MyService_notify_args {
 public:

  MyService_notify_args() {
  }

  virtual ~MyService_notify_args() throw() {}

  finger_entry n;

  _MyService_notify_args__isset __isset;

  void __set_n(const finger_entry& val) {
    n = val;
  }

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

  bool operator < (const MyService_notify_args & ) const;

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

};


class MyService_notify_pargs {
 public:


  virtual ~MyService_notify_pargs() throw() {}

  const finger_entry* n;

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

};


class MyService_notify_result {
 public:

  MyService_notify_result() {
  }

  virtual ~MyService_notify_result() throw() {}


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

  bool operator < (const MyService_notify_result & ) const;

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

};


class MyService_notify_presult {
 public:


  virtual ~MyService_notify_presult() throw() {}


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

};

typedef struct _MyService_gateway_add_file_self_args__isset {
  _MyService_gateway_add_file_self_args__isset() : name(false), content(false) {}
  bool name;
  bool content;
} _MyService_gateway_add_file_self_args__isset;

class MyService_gateway_add_file_self_args {
 public:

  MyService_gateway_add_file_self_args() : name(""), content("") {
  }

  virtual ~MyService_gateway_add_file_self_args() throw() {}

  std::string name;
  std::string content;

  _MyService_gateway_add_file_self_args__isset __isset;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_content(const std::string& val) {
    content = val;
  }

  bool operator == (const MyService_gateway_add_file_self_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(content == rhs.content))
      return false;
    return true;
  }
  bool operator != (const MyService_gateway_add_file_self_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MyService_gateway_add_file_self_args & ) const;

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

};


class MyService_gateway_add_file_self_pargs {
 public:


  virtual ~MyService_gateway_add_file_self_pargs() throw() {}

  const std::string* name;
  const std::string* content;

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

};

typedef struct _MyService_gateway_add_file_self_result__isset {
  _MyService_gateway_add_file_self_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_add_file_self_result__isset;

class MyService_gateway_add_file_self_result {
 public:

  MyService_gateway_add_file_self_result() : success("") {
  }

  virtual ~MyService_gateway_add_file_self_result() throw() {}

  std::string success;

  _MyService_gateway_add_file_self_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_add_file_self_result & ) const;

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

};

typedef struct _MyService_gateway_add_file_self_presult__isset {
  _MyService_gateway_add_file_self_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_add_file_self_presult__isset;

class MyService_gateway_add_file_self_presult {
 public:


  virtual ~MyService_gateway_add_file_self_presult() throw() {}

  std::string* success;

  _MyService_gateway_add_file_self_presult__isset __isset;

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

};

typedef struct _MyService_gateway_add_file_other_args__isset {
  _MyService_gateway_add_file_other_args__isset() : name(false), content(false) {}
  bool name;
  bool content;
} _MyService_gateway_add_file_other_args__isset;

class MyService_gateway_add_file_other_args {
 public:

  MyService_gateway_add_file_other_args() : name(""), content("") {
  }

  virtual ~MyService_gateway_add_file_other_args() throw() {}

  std::string name;
  std::string content;

  _MyService_gateway_add_file_other_args__isset __isset;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_content(const std::string& val) {
    content = val;
  }

  bool operator == (const MyService_gateway_add_file_other_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(content == rhs.content))
      return false;
    return true;
  }
  bool operator != (const MyService_gateway_add_file_other_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const MyService_gateway_add_file_other_args & ) const;

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

};


class MyService_gateway_add_file_other_pargs {
 public:


  virtual ~MyService_gateway_add_file_other_pargs() throw() {}

  const std::string* name;
  const std::string* content;

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

};

typedef struct _MyService_gateway_add_file_other_result__isset {
  _MyService_gateway_add_file_other_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_add_file_other_result__isset;

class MyService_gateway_add_file_other_result {
 public:

  MyService_gateway_add_file_other_result() : success("") {
  }

  virtual ~MyService_gateway_add_file_other_result() throw() {}

  std::string success;

  _MyService_gateway_add_file_other_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_add_file_other_result & ) const;

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

};

typedef struct _MyService_gateway_add_file_other_presult__isset {
  _MyService_gateway_add_file_other_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_add_file_other_presult__isset;

class MyService_gateway_add_file_other_presult {
 public:


  virtual ~MyService_gateway_add_file_other_presult() throw() {}

  std::string* success;

  _MyService_gateway_add_file_other_presult__isset __isset;

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

};

typedef struct _MyService_gateway_del_file_self_args__isset {
  _MyService_gateway_del_file_self_args__isset() : name(false) {}
  bool name;
} _MyService_gateway_del_file_self_args__isset;

class MyService_gateway_del_file_self_args {
 public:

  MyService_gateway_del_file_self_args() : name("") {
  }

  virtual ~MyService_gateway_del_file_self_args() throw() {}

  std::string name;

  _MyService_gateway_del_file_self_args__isset __isset;

  void __set_name(const std::string& val) {
    name = val;
  }

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

  bool operator < (const MyService_gateway_del_file_self_args & ) const;

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

};


class MyService_gateway_del_file_self_pargs {
 public:


  virtual ~MyService_gateway_del_file_self_pargs() throw() {}

  const std::string* name;

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

};

typedef struct _MyService_gateway_del_file_self_result__isset {
  _MyService_gateway_del_file_self_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_del_file_self_result__isset;

class MyService_gateway_del_file_self_result {
 public:

  MyService_gateway_del_file_self_result() : success("") {
  }

  virtual ~MyService_gateway_del_file_self_result() throw() {}

  std::string success;

  _MyService_gateway_del_file_self_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_del_file_self_result & ) const;

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

};

typedef struct _MyService_gateway_del_file_self_presult__isset {
  _MyService_gateway_del_file_self_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_del_file_self_presult__isset;

class MyService_gateway_del_file_self_presult {
 public:


  virtual ~MyService_gateway_del_file_self_presult() throw() {}

  std::string* success;

  _MyService_gateway_del_file_self_presult__isset __isset;

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

};

typedef struct _MyService_gateway_del_file_other_args__isset {
  _MyService_gateway_del_file_other_args__isset() : name(false) {}
  bool name;
} _MyService_gateway_del_file_other_args__isset;

class MyService_gateway_del_file_other_args {
 public:

  MyService_gateway_del_file_other_args() : name("") {
  }

  virtual ~MyService_gateway_del_file_other_args() throw() {}

  std::string name;

  _MyService_gateway_del_file_other_args__isset __isset;

  void __set_name(const std::string& val) {
    name = val;
  }

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

  bool operator < (const MyService_gateway_del_file_other_args & ) const;

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

};


class MyService_gateway_del_file_other_pargs {
 public:


  virtual ~MyService_gateway_del_file_other_pargs() throw() {}

  const std::string* name;

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

};

typedef struct _MyService_gateway_del_file_other_result__isset {
  _MyService_gateway_del_file_other_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_del_file_other_result__isset;

class MyService_gateway_del_file_other_result {
 public:

  MyService_gateway_del_file_other_result() : success("") {
  }

  virtual ~MyService_gateway_del_file_other_result() throw() {}

  std::string success;

  _MyService_gateway_del_file_other_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_del_file_other_result & ) const;

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

};

typedef struct _MyService_gateway_del_file_other_presult__isset {
  _MyService_gateway_del_file_other_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_del_file_other_presult__isset;

class MyService_gateway_del_file_other_presult {
 public:


  virtual ~MyService_gateway_del_file_other_presult() throw() {}

  std::string* success;

  _MyService_gateway_del_file_other_presult__isset __isset;

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

};

typedef struct _MyService_gateway_get_file_self_args__isset {
  _MyService_gateway_get_file_self_args__isset() : name(false) {}
  bool name;
} _MyService_gateway_get_file_self_args__isset;

class MyService_gateway_get_file_self_args {
 public:

  MyService_gateway_get_file_self_args() : name("") {
  }

  virtual ~MyService_gateway_get_file_self_args() throw() {}

  std::string name;

  _MyService_gateway_get_file_self_args__isset __isset;

  void __set_name(const std::string& val) {
    name = val;
  }

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

  bool operator < (const MyService_gateway_get_file_self_args & ) const;

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

};


class MyService_gateway_get_file_self_pargs {
 public:


  virtual ~MyService_gateway_get_file_self_pargs() throw() {}

  const std::string* name;

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

};

typedef struct _MyService_gateway_get_file_self_result__isset {
  _MyService_gateway_get_file_self_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_file_self_result__isset;

class MyService_gateway_get_file_self_result {
 public:

  MyService_gateway_get_file_self_result() : success("") {
  }

  virtual ~MyService_gateway_get_file_self_result() throw() {}

  std::string success;

  _MyService_gateway_get_file_self_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_get_file_self_result & ) const;

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

};

typedef struct _MyService_gateway_get_file_self_presult__isset {
  _MyService_gateway_get_file_self_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_file_self_presult__isset;

class MyService_gateway_get_file_self_presult {
 public:


  virtual ~MyService_gateway_get_file_self_presult() throw() {}

  std::string* success;

  _MyService_gateway_get_file_self_presult__isset __isset;

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

};

typedef struct _MyService_gateway_get_file_other_args__isset {
  _MyService_gateway_get_file_other_args__isset() : name(false) {}
  bool name;
} _MyService_gateway_get_file_other_args__isset;

class MyService_gateway_get_file_other_args {
 public:

  MyService_gateway_get_file_other_args() : name("") {
  }

  virtual ~MyService_gateway_get_file_other_args() throw() {}

  std::string name;

  _MyService_gateway_get_file_other_args__isset __isset;

  void __set_name(const std::string& val) {
    name = val;
  }

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

  bool operator < (const MyService_gateway_get_file_other_args & ) const;

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

};


class MyService_gateway_get_file_other_pargs {
 public:


  virtual ~MyService_gateway_get_file_other_pargs() throw() {}

  const std::string* name;

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

};

typedef struct _MyService_gateway_get_file_other_result__isset {
  _MyService_gateway_get_file_other_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_file_other_result__isset;

class MyService_gateway_get_file_other_result {
 public:

  MyService_gateway_get_file_other_result() : success("") {
  }

  virtual ~MyService_gateway_get_file_other_result() throw() {}

  std::string success;

  _MyService_gateway_get_file_other_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_get_file_other_result & ) const;

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

};

typedef struct _MyService_gateway_get_file_other_presult__isset {
  _MyService_gateway_get_file_other_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_file_other_presult__isset;

class MyService_gateway_get_file_other_presult {
 public:


  virtual ~MyService_gateway_get_file_other_presult() throw() {}

  std::string* success;

  _MyService_gateway_get_file_other_presult__isset __isset;

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

};


class MyService_gateway_get_self_table_args {
 public:

  MyService_gateway_get_self_table_args() {
  }

  virtual ~MyService_gateway_get_self_table_args() throw() {}


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

  bool operator < (const MyService_gateway_get_self_table_args & ) const;

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

};


class MyService_gateway_get_self_table_pargs {
 public:


  virtual ~MyService_gateway_get_self_table_pargs() throw() {}


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

};

typedef struct _MyService_gateway_get_self_table_result__isset {
  _MyService_gateway_get_self_table_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_self_table_result__isset;

class MyService_gateway_get_self_table_result {
 public:

  MyService_gateway_get_self_table_result() : success("") {
  }

  virtual ~MyService_gateway_get_self_table_result() throw() {}

  std::string success;

  _MyService_gateway_get_self_table_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_get_self_table_result & ) const;

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

};

typedef struct _MyService_gateway_get_self_table_presult__isset {
  _MyService_gateway_get_self_table_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_self_table_presult__isset;

class MyService_gateway_get_self_table_presult {
 public:


  virtual ~MyService_gateway_get_self_table_presult() throw() {}

  std::string* success;

  _MyService_gateway_get_self_table_presult__isset __isset;

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

};

typedef struct _MyService_gateway_get_other_table_args__isset {
  _MyService_gateway_get_other_table_args__isset() : id(false) {}
  bool id;
} _MyService_gateway_get_other_table_args__isset;

class MyService_gateway_get_other_table_args {
 public:

  MyService_gateway_get_other_table_args() : id(0) {
  }

  virtual ~MyService_gateway_get_other_table_args() throw() {}

  int32_t id;

  _MyService_gateway_get_other_table_args__isset __isset;

  void __set_id(const int32_t val) {
    id = val;
  }

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

  bool operator < (const MyService_gateway_get_other_table_args & ) const;

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

};


class MyService_gateway_get_other_table_pargs {
 public:


  virtual ~MyService_gateway_get_other_table_pargs() throw() {}

  const int32_t* id;

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

};

typedef struct _MyService_gateway_get_other_table_result__isset {
  _MyService_gateway_get_other_table_result__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_other_table_result__isset;

class MyService_gateway_get_other_table_result {
 public:

  MyService_gateway_get_other_table_result() : success("") {
  }

  virtual ~MyService_gateway_get_other_table_result() throw() {}

  std::string success;

  _MyService_gateway_get_other_table_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

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

  bool operator < (const MyService_gateway_get_other_table_result & ) const;

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

};

typedef struct _MyService_gateway_get_other_table_presult__isset {
  _MyService_gateway_get_other_table_presult__isset() : success(false) {}
  bool success;
} _MyService_gateway_get_other_table_presult__isset;

class MyService_gateway_get_other_table_presult {
 public:


  virtual ~MyService_gateway_get_other_table_presult() throw() {}

  std::string* success;

  _MyService_gateway_get_other_table_presult__isset __isset;

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

};

class MyServiceClient : virtual public MyServiceIf {
 public:
  MyServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
    piprot_(prot),
    poprot_(prot) {
    iprot_ = prot.get();
    oprot_ = prot.get();
  }
  MyServiceClient(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 get_predecessor(finger_entry& _return);
  void send_get_predecessor();
  void recv_get_predecessor(finger_entry& _return);
  void get_successor(finger_entry& _return);
  void send_get_successor();
  void recv_get_successor(finger_entry& _return);
  void find_successor(finger_entry& _return, const int32_t id);
  void send_find_successor(const int32_t id);
  void recv_find_successor(finger_entry& _return);
  void find_predecessor(finger_entry& _return, const int32_t id);
  void send_find_predecessor(const int32_t id);
  void recv_find_predecessor(finger_entry& _return);
  void closest_preceding_finger(finger_entry& _return, const int32_t id);
  void send_closest_preceding_finger(const int32_t id);
  void recv_closest_preceding_finger(finger_entry& _return);
  void notify(const finger_entry& n);
  void send_notify(const finger_entry& n);
  void recv_notify();
  void gateway_add_file_self(std::string& _return, const std::string& name, const std::string& content);
  void send_gateway_add_file_self(const std::string& name, const std::string& content);
  void recv_gateway_add_file_self(std::string& _return);
  void gateway_add_file_other(std::string& _return, const std::string& name, const std::string& content);
  void send_gateway_add_file_other(const std::string& name, const std::string& content);
  void recv_gateway_add_file_other(std::string& _return);
  void gateway_del_file_self(std::string& _return, const std::string& name);
  void send_gateway_del_file_self(const std::string& name);
  void recv_gateway_del_file_self(std::string& _return);
  void gateway_del_file_other(std::string& _return, const std::string& name);
  void send_gateway_del_file_other(const std::string& name);
  void recv_gateway_del_file_other(std::string& _return);
  void gateway_get_file_self(std::string& _return, const std::string& name);
  void send_gateway_get_file_self(const std::string& name);
  void recv_gateway_get_file_self(std::string& _return);
  void gateway_get_file_other(std::string& _return, const std::string& name);
  void send_gateway_get_file_other(const std::string& name);
  void recv_gateway_get_file_other(std::string& _return);
  void gateway_get_self_table(std::string& _return);
  void send_gateway_get_self_table();
  void recv_gateway_get_self_table(std::string& _return);
  void gateway_get_other_table(std::string& _return, const int32_t id);
  void send_gateway_get_other_table(const int32_t id);
  void recv_gateway_get_other_table(std::string& _return);
 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 MyServiceProcessor : public ::apache::thrift::TProcessor {
 protected:
  boost::shared_ptr<MyServiceIf> iface_;
  virtual bool process_fn(apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext);
 private:
  std::map<std::string, void (MyServiceProcessor::*)(int32_t, apache::thrift::protocol::TProtocol*, apache::thrift::protocol::TProtocol*, void*)> processMap_;
  void process_get_predecessor(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_successor(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_find_successor(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_find_predecessor(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_closest_preceding_finger(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_notify(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_add_file_self(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_add_file_other(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_del_file_self(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_del_file_other(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_get_file_self(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_get_file_other(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_get_self_table(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_gateway_get_other_table(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  MyServiceProcessor(boost::shared_ptr<MyServiceIf> iface) :
    iface_(iface) {
    processMap_["get_predecessor"] = &MyServiceProcessor::process_get_predecessor;
    processMap_["get_successor"] = &MyServiceProcessor::process_get_successor;
    processMap_["find_successor"] = &MyServiceProcessor::process_find_successor;
    processMap_["find_predecessor"] = &MyServiceProcessor::process_find_predecessor;
    processMap_["closest_preceding_finger"] = &MyServiceProcessor::process_closest_preceding_finger;
    processMap_["notify"] = &MyServiceProcessor::process_notify;
    processMap_["gateway_add_file_self"] = &MyServiceProcessor::process_gateway_add_file_self;
    processMap_["gateway_add_file_other"] = &MyServiceProcessor::process_gateway_add_file_other;
    processMap_["gateway_del_file_self"] = &MyServiceProcessor::process_gateway_del_file_self;
    processMap_["gateway_del_file_other"] = &MyServiceProcessor::process_gateway_del_file_other;
    processMap_["gateway_get_file_self"] = &MyServiceProcessor::process_gateway_get_file_self;
    processMap_["gateway_get_file_other"] = &MyServiceProcessor::process_gateway_get_file_other;
    processMap_["gateway_get_self_table"] = &MyServiceProcessor::process_gateway_get_self_table;
    processMap_["gateway_get_other_table"] = &MyServiceProcessor::process_gateway_get_other_table;
  }

  virtual bool process(boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot, void* callContext);
  virtual ~MyServiceProcessor() {}
};

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

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

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

class MyServiceMultiface : virtual public MyServiceIf {
 public:
  MyServiceMultiface(std::vector<boost::shared_ptr<MyServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~MyServiceMultiface() {}
 protected:
  std::vector<boost::shared_ptr<MyServiceIf> > ifaces_;
  MyServiceMultiface() {}
  void add(boost::shared_ptr<MyServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void get_predecessor(finger_entry& _return) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->get_predecessor(_return);
        return;
      } else {
        ifaces_[i]->get_predecessor(_return);
      }
    }
  }

  void get_successor(finger_entry& _return) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->get_successor(_return);
        return;
      } else {
        ifaces_[i]->get_successor(_return);
      }
    }
  }

  void find_successor(finger_entry& _return, const int32_t id) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->find_successor(_return, id);
        return;
      } else {
        ifaces_[i]->find_successor(_return, id);
      }
    }
  }

  void find_predecessor(finger_entry& _return, const int32_t id) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->find_predecessor(_return, id);
        return;
      } else {
        ifaces_[i]->find_predecessor(_return, id);
      }
    }
  }

  void closest_preceding_finger(finger_entry& _return, const int32_t id) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->closest_preceding_finger(_return, id);
        return;
      } else {
        ifaces_[i]->closest_preceding_finger(_return, id);
      }
    }
  }

  void notify(const finger_entry& n) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      ifaces_[i]->notify(n);
    }
  }

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

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

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

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

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

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

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

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

};

} // namespace

#endif