text: /**
   * Autogenerated by Thrift Compiler (0.10.0)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #ifndef MetadataIndexService_H
  #define MetadataIndexService_H
  
  #include <thrift/TDispatchProcessor.h>
  #include <thrift/async/TConcurrentClientSyncInfo.h>
  #include "indexfs_types.h"
  
  namespace indexfs {
  
  #ifdef _WIN32
    #pragma warning( push )
    #pragma warning (disable : 4250 ) //inheriting methods via dominance 
  #endif
  
  class MetadataIndexServiceIf {
   public:
    virtual ~MetadataIndexServiceIf() {}
    virtual void Ping() = 0;
    virtual void FlushDB() = 0;
    virtual void Access(LookupInfo& _return, const OID& obj_id) = 0;
    virtual void Renew(LookupInfo& _return, const OID& obj_id) = 0;
    virtual void Getattr(StatInfo& _return, const OID& obj_id) = 0;
    virtual void Mknod(const OID& obj_id, const int16_t perm) = 0;
    virtual void Mknod_Bulk(const OIDS& obj_ids, const int16_t perm) = 0;
    virtual void Mkdir(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2) = 0;
    virtual void Mkdir_Presplit(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2) = 0;
    virtual bool Chmod(const OID& obj_id, const int16_t perm) = 0;
    virtual bool Chown(const OID& obj_id, const int16_t uid, const int16_t gid) = 0;
    virtual void CreateZeroth(const int64_t dir_id, const int16_t zeroth_server) = 0;
    virtual void Readdir(EntryList& _return, const int64_t dir_id, const int16_t index) = 0;
    virtual void ReadBitmap(std::string& _return, const int64_t dir_id) = 0;
    virtual void UpdateBitmap(const int64_t dir_id, const std::string& dmap_data) = 0;
    virtual void InsertSplit(const int64_t dir_id, const int16_t parent_index, const int16_t child_index, const std::string& path_split_files, const std::string& dmap_data, const int64_t min_seq, const int64_t max_seq, const int64_t num_entries) = 0;
  };
  
  class MetadataIndexServiceIfFactory {
   public:
    typedef MetadataIndexServiceIf Handler;
  
    virtual ~MetadataIndexServiceIfFactory() {}
  
    virtual MetadataIndexServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
    virtual void releaseHandler(MetadataIndexServiceIf* /* handler */) = 0;
  };
  
  class MetadataIndexServiceIfSingletonFactory : virtual public MetadataIndexServiceIfFactory {
   public:
    MetadataIndexServiceIfSingletonFactory(const boost::shared_ptr<MetadataIndexServiceIf>& iface) : iface_(iface) {}
    virtual ~MetadataIndexServiceIfSingletonFactory() {}
  
    virtual MetadataIndexServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
      return iface_.get();
    }
    virtual void releaseHandler(MetadataIndexServiceIf* /* handler */) {}
  
   protected:
    boost::shared_ptr<MetadataIndexServiceIf> iface_;
  };
  
  class MetadataIndexServiceNull : virtual public MetadataIndexServiceIf {
   public:
    virtual ~MetadataIndexServiceNull() {}
    void Ping() {
      return;
    }
    void FlushDB() {
      return;
    }
    void Access(LookupInfo& /* _return */, const OID& /* obj_id */) {
      return;
    }
    void Renew(LookupInfo& /* _return */, const OID& /* obj_id */) {
      return;
    }
    void Getattr(StatInfo& /* _return */, const OID& /* obj_id */) {
      return;
    }
    void Mknod(const OID& /* obj_id */, const int16_t /* perm */) {
      return;
    }
    void Mknod_Bulk(const OIDS& /* obj_ids */, const int16_t /* perm */) {
      return;
    }
    void Mkdir(const OID& /* obj_id */, const int16_t /* perm */, const int16_t /* hint_server1 */, const int16_t /* hint_server2 */) {
      return;
    }
    void Mkdir_Presplit(const OID& /* obj_id */, const int16_t /* perm */, const int16_t /* hint_server1 */, const int16_t /* hint_server2 */) {
      return;
    }
    bool Chmod(const OID& /* obj_id */, const int16_t /* perm */) {
      bool _return = false;
      return _return;
    }
    bool Chown(const OID& /* obj_id */, const int16_t /* uid */, const int16_t /* gid */) {
      bool _return = false;
      return _return;
    }
    void CreateZeroth(const int64_t /* dir_id */, const int16_t /* zeroth_server */) {
      return;
    }
    void Readdir(EntryList& /* _return */, const int64_t /* dir_id */, const int16_t /* index */) {
      return;
    }
    void ReadBitmap(std::string& /* _return */, const int64_t /* dir_id */) {
      return;
    }
    void UpdateBitmap(const int64_t /* dir_id */, const std::string& /* dmap_data */) {
      return;
    }
    void InsertSplit(const int64_t /* dir_id */, const int16_t /* parent_index */, const int16_t /* child_index */, const std::string& /* path_split_files */, const std::string& /* dmap_data */, const int64_t /* min_seq */, const int64_t /* max_seq */, const int64_t /* num_entries */) {
      return;
    }
  };
  
  
  class MetadataIndexService_Ping_args {
   public:
  
    MetadataIndexService_Ping_args(const MetadataIndexService_Ping_args&);
    MetadataIndexService_Ping_args& operator=(const MetadataIndexService_Ping_args&);
    MetadataIndexService_Ping_args() {
    }
  
    virtual ~MetadataIndexService_Ping_args() throw();
  
    bool operator == (const MetadataIndexService_Ping_args & /* rhs */) const
    {
      return true;
    }
    bool operator != (const MetadataIndexService_Ping_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Ping_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Ping_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Ping_pargs() throw();
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Ping_result__isset {
    _MetadataIndexService_Ping_result__isset() : srv_error(false) {}
    bool srv_error :1;
  } _MetadataIndexService_Ping_result__isset;
  
  class MetadataIndexService_Ping_result {
   public:
  
    MetadataIndexService_Ping_result(const MetadataIndexService_Ping_result&);
    MetadataIndexService_Ping_result& operator=(const MetadataIndexService_Ping_result&);
    MetadataIndexService_Ping_result() {
    }
  
    virtual ~MetadataIndexService_Ping_result() throw();
    ServerInternalError srv_error;
  
    _MetadataIndexService_Ping_result__isset __isset;
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Ping_result & rhs) const
    {
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Ping_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Ping_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Ping_presult__isset {
    _MetadataIndexService_Ping_presult__isset() : srv_error(false) {}
    bool srv_error :1;
  } _MetadataIndexService_Ping_presult__isset;
  
  class MetadataIndexService_Ping_presult {
   public:
  
  
    virtual ~MetadataIndexService_Ping_presult() throw();
    ServerInternalError srv_error;
  
    _MetadataIndexService_Ping_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  
  class MetadataIndexService_FlushDB_args {
   public:
  
    MetadataIndexService_FlushDB_args(const MetadataIndexService_FlushDB_args&);
    MetadataIndexService_FlushDB_args& operator=(const MetadataIndexService_FlushDB_args&);
    MetadataIndexService_FlushDB_args() {
    }
  
    virtual ~MetadataIndexService_FlushDB_args() throw();
  
    bool operator == (const MetadataIndexService_FlushDB_args & /* rhs */) const
    {
      return true;
    }
    bool operator != (const MetadataIndexService_FlushDB_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_FlushDB_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_FlushDB_pargs {
   public:
  
  
    virtual ~MetadataIndexService_FlushDB_pargs() throw();
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_FlushDB_result__isset {
    _MetadataIndexService_FlushDB_result__isset() : io_error(false), srv_error(false) {}
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_FlushDB_result__isset;
  
  class MetadataIndexService_FlushDB_result {
   public:
  
    MetadataIndexService_FlushDB_result(const MetadataIndexService_FlushDB_result&);
    MetadataIndexService_FlushDB_result& operator=(const MetadataIndexService_FlushDB_result&);
    MetadataIndexService_FlushDB_result() {
    }
  
    virtual ~MetadataIndexService_FlushDB_result() throw();
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_FlushDB_result__isset __isset;
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_FlushDB_result & rhs) const
    {
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_FlushDB_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_FlushDB_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_FlushDB_presult__isset {
    _MetadataIndexService_FlushDB_presult__isset() : io_error(false), srv_error(false) {}
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_FlushDB_presult__isset;
  
  class MetadataIndexService_FlushDB_presult {
   public:
  
  
    virtual ~MetadataIndexService_FlushDB_presult() throw();
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_FlushDB_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Access_args__isset {
    _MetadataIndexService_Access_args__isset() : obj_id(false) {}
    bool obj_id :1;
  } _MetadataIndexService_Access_args__isset;
  
  class MetadataIndexService_Access_args {
   public:
  
    MetadataIndexService_Access_args(const MetadataIndexService_Access_args&);
    MetadataIndexService_Access_args& operator=(const MetadataIndexService_Access_args&);
    MetadataIndexService_Access_args() {
    }
  
    virtual ~MetadataIndexService_Access_args() throw();
    OID obj_id;
  
    _MetadataIndexService_Access_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    bool operator == (const MetadataIndexService_Access_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Access_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Access_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Access_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Access_pargs() throw();
    const OID* obj_id;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Access_result__isset {
    _MetadataIndexService_Access_result__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), not_a_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool not_a_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Access_result__isset;
  
  class MetadataIndexService_Access_result {
   public:
  
    MetadataIndexService_Access_result(const MetadataIndexService_Access_result&);
    MetadataIndexService_Access_result& operator=(const MetadataIndexService_Access_result&);
    MetadataIndexService_Access_result() {
    }
  
    virtual ~MetadataIndexService_Access_result() throw();
    LookupInfo success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    DirectoryExpectedError not_a_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Access_result__isset __isset;
  
    void __set_success(const LookupInfo& val);
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_not_found(const FileNotFoundException& val);
  
    void __set_not_a_dir(const DirectoryExpectedError& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Access_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(not_found == rhs.not_found))
        return false;
      if (!(not_a_dir == rhs.not_a_dir))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Access_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Access_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Access_presult__isset {
    _MetadataIndexService_Access_presult__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), not_a_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool not_a_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Access_presult__isset;
  
  class MetadataIndexService_Access_presult {
   public:
  
  
    virtual ~MetadataIndexService_Access_presult() throw();
    LookupInfo* success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    DirectoryExpectedError not_a_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Access_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Renew_args__isset {
    _MetadataIndexService_Renew_args__isset() : obj_id(false) {}
    bool obj_id :1;
  } _MetadataIndexService_Renew_args__isset;
  
  class MetadataIndexService_Renew_args {
   public:
  
    MetadataIndexService_Renew_args(const MetadataIndexService_Renew_args&);
    MetadataIndexService_Renew_args& operator=(const MetadataIndexService_Renew_args&);
    MetadataIndexService_Renew_args() {
    }
  
    virtual ~MetadataIndexService_Renew_args() throw();
    OID obj_id;
  
    _MetadataIndexService_Renew_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    bool operator == (const MetadataIndexService_Renew_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Renew_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Renew_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Renew_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Renew_pargs() throw();
    const OID* obj_id;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Renew_result__isset {
    _MetadataIndexService_Renew_result__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), not_a_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool not_a_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Renew_result__isset;
  
  class MetadataIndexService_Renew_result {
   public:
  
    MetadataIndexService_Renew_result(const MetadataIndexService_Renew_result&);
    MetadataIndexService_Renew_result& operator=(const MetadataIndexService_Renew_result&);
    MetadataIndexService_Renew_result() {
    }
  
    virtual ~MetadataIndexService_Renew_result() throw();
    LookupInfo success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    DirectoryExpectedError not_a_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Renew_result__isset __isset;
  
    void __set_success(const LookupInfo& val);
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_not_found(const FileNotFoundException& val);
  
    void __set_not_a_dir(const DirectoryExpectedError& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Renew_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(not_found == rhs.not_found))
        return false;
      if (!(not_a_dir == rhs.not_a_dir))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Renew_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Renew_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Renew_presult__isset {
    _MetadataIndexService_Renew_presult__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), not_a_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool not_a_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Renew_presult__isset;
  
  class MetadataIndexService_Renew_presult {
   public:
  
  
    virtual ~MetadataIndexService_Renew_presult() throw();
    LookupInfo* success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    DirectoryExpectedError not_a_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Renew_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Getattr_args__isset {
    _MetadataIndexService_Getattr_args__isset() : obj_id(false) {}
    bool obj_id :1;
  } _MetadataIndexService_Getattr_args__isset;
  
  class MetadataIndexService_Getattr_args {
   public:
  
    MetadataIndexService_Getattr_args(const MetadataIndexService_Getattr_args&);
    MetadataIndexService_Getattr_args& operator=(const MetadataIndexService_Getattr_args&);
    MetadataIndexService_Getattr_args() {
    }
  
    virtual ~MetadataIndexService_Getattr_args() throw();
    OID obj_id;
  
    _MetadataIndexService_Getattr_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    bool operator == (const MetadataIndexService_Getattr_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Getattr_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Getattr_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Getattr_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Getattr_pargs() throw();
    const OID* obj_id;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Getattr_result__isset {
    _MetadataIndexService_Getattr_result__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Getattr_result__isset;
  
  class MetadataIndexService_Getattr_result {
   public:
  
    MetadataIndexService_Getattr_result(const MetadataIndexService_Getattr_result&);
    MetadataIndexService_Getattr_result& operator=(const MetadataIndexService_Getattr_result&);
    MetadataIndexService_Getattr_result() {
    }
  
    virtual ~MetadataIndexService_Getattr_result() throw();
    StatInfo success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Getattr_result__isset __isset;
  
    void __set_success(const StatInfo& val);
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_not_found(const FileNotFoundException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Getattr_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(not_found == rhs.not_found))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Getattr_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Getattr_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Getattr_presult__isset {
    _MetadataIndexService_Getattr_presult__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Getattr_presult__isset;
  
  class MetadataIndexService_Getattr_presult {
   public:
  
  
    virtual ~MetadataIndexService_Getattr_presult() throw();
    StatInfo* success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Getattr_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Mknod_args__isset {
    _MetadataIndexService_Mknod_args__isset() : obj_id(false), perm(false) {}
    bool obj_id :1;
    bool perm :1;
  } _MetadataIndexService_Mknod_args__isset;
  
  class MetadataIndexService_Mknod_args {
   public:
  
    MetadataIndexService_Mknod_args(const MetadataIndexService_Mknod_args&);
    MetadataIndexService_Mknod_args& operator=(const MetadataIndexService_Mknod_args&);
    MetadataIndexService_Mknod_args() : perm(0) {
    }
  
    virtual ~MetadataIndexService_Mknod_args() throw();
    OID obj_id;
    int16_t perm;
  
    _MetadataIndexService_Mknod_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    void __set_perm(const int16_t val);
  
    bool operator == (const MetadataIndexService_Mknod_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      if (!(perm == rhs.perm))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mknod_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mknod_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Mknod_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Mknod_pargs() throw();
    const OID* obj_id;
    const int16_t* perm;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mknod_result__isset {
    _MetadataIndexService_Mknod_result__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mknod_result__isset;
  
  class MetadataIndexService_Mknod_result {
   public:
  
    MetadataIndexService_Mknod_result(const MetadataIndexService_Mknod_result&);
    MetadataIndexService_Mknod_result& operator=(const MetadataIndexService_Mknod_result&);
    MetadataIndexService_Mknod_result() {
    }
  
    virtual ~MetadataIndexService_Mknod_result() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mknod_result__isset __isset;
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_file_exists(const FileAlreadyExistsException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Mknod_result & rhs) const
    {
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(file_exists == rhs.file_exists))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mknod_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mknod_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mknod_presult__isset {
    _MetadataIndexService_Mknod_presult__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mknod_presult__isset;
  
  class MetadataIndexService_Mknod_presult {
   public:
  
  
    virtual ~MetadataIndexService_Mknod_presult() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mknod_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Mknod_Bulk_args__isset {
    _MetadataIndexService_Mknod_Bulk_args__isset() : obj_ids(false), perm(false) {}
    bool obj_ids :1;
    bool perm :1;
  } _MetadataIndexService_Mknod_Bulk_args__isset;
  
  class MetadataIndexService_Mknod_Bulk_args {
   public:
  
    MetadataIndexService_Mknod_Bulk_args(const MetadataIndexService_Mknod_Bulk_args&);
    MetadataIndexService_Mknod_Bulk_args& operator=(const MetadataIndexService_Mknod_Bulk_args&);
    MetadataIndexService_Mknod_Bulk_args() : perm(0) {
    }
  
    virtual ~MetadataIndexService_Mknod_Bulk_args() throw();
    OIDS obj_ids;
    int16_t perm;
  
    _MetadataIndexService_Mknod_Bulk_args__isset __isset;
  
    void __set_obj_ids(const OIDS& val);
  
    void __set_perm(const int16_t val);
  
    bool operator == (const MetadataIndexService_Mknod_Bulk_args & rhs) const
    {
      if (!(obj_ids == rhs.obj_ids))
        return false;
      if (!(perm == rhs.perm))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mknod_Bulk_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mknod_Bulk_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Mknod_Bulk_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Mknod_Bulk_pargs() throw();
    const OIDS* obj_ids;
    const int16_t* perm;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mknod_Bulk_result__isset {
    _MetadataIndexService_Mknod_Bulk_result__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mknod_Bulk_result__isset;
  
  class MetadataIndexService_Mknod_Bulk_result {
   public:
  
    MetadataIndexService_Mknod_Bulk_result(const MetadataIndexService_Mknod_Bulk_result&);
    MetadataIndexService_Mknod_Bulk_result& operator=(const MetadataIndexService_Mknod_Bulk_result&);
    MetadataIndexService_Mknod_Bulk_result() {
    }
  
    virtual ~MetadataIndexService_Mknod_Bulk_result() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mknod_Bulk_result__isset __isset;
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_file_exists(const FileAlreadyExistsException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Mknod_Bulk_result & rhs) const
    {
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(file_exists == rhs.file_exists))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mknod_Bulk_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mknod_Bulk_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mknod_Bulk_presult__isset {
    _MetadataIndexService_Mknod_Bulk_presult__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mknod_Bulk_presult__isset;
  
  class MetadataIndexService_Mknod_Bulk_presult {
   public:
  
  
    virtual ~MetadataIndexService_Mknod_Bulk_presult() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mknod_Bulk_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Mkdir_args__isset {
    _MetadataIndexService_Mkdir_args__isset() : obj_id(false), perm(false), hint_server1(false), hint_server2(false) {}
    bool obj_id :1;
    bool perm :1;
    bool hint_server1 :1;
    bool hint_server2 :1;
  } _MetadataIndexService_Mkdir_args__isset;
  
  class MetadataIndexService_Mkdir_args {
   public:
  
    MetadataIndexService_Mkdir_args(const MetadataIndexService_Mkdir_args&);
    MetadataIndexService_Mkdir_args& operator=(const MetadataIndexService_Mkdir_args&);
    MetadataIndexService_Mkdir_args() : perm(0), hint_server1(0), hint_server2(0) {
    }
  
    virtual ~MetadataIndexService_Mkdir_args() throw();
    OID obj_id;
    int16_t perm;
    int16_t hint_server1;
    int16_t hint_server2;
  
    _MetadataIndexService_Mkdir_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    void __set_perm(const int16_t val);
  
    void __set_hint_server1(const int16_t val);
  
    void __set_hint_server2(const int16_t val);
  
    bool operator == (const MetadataIndexService_Mkdir_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      if (!(perm == rhs.perm))
        return false;
      if (!(hint_server1 == rhs.hint_server1))
        return false;
      if (!(hint_server2 == rhs.hint_server2))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mkdir_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mkdir_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Mkdir_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Mkdir_pargs() throw();
    const OID* obj_id;
    const int16_t* perm;
    const int16_t* hint_server1;
    const int16_t* hint_server2;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mkdir_result__isset {
    _MetadataIndexService_Mkdir_result__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mkdir_result__isset;
  
  class MetadataIndexService_Mkdir_result {
   public:
  
    MetadataIndexService_Mkdir_result(const MetadataIndexService_Mkdir_result&);
    MetadataIndexService_Mkdir_result& operator=(const MetadataIndexService_Mkdir_result&);
    MetadataIndexService_Mkdir_result() {
    }
  
    virtual ~MetadataIndexService_Mkdir_result() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mkdir_result__isset __isset;
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_file_exists(const FileAlreadyExistsException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Mkdir_result & rhs) const
    {
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(file_exists == rhs.file_exists))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mkdir_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mkdir_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mkdir_presult__isset {
    _MetadataIndexService_Mkdir_presult__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mkdir_presult__isset;
  
  class MetadataIndexService_Mkdir_presult {
   public:
  
  
    virtual ~MetadataIndexService_Mkdir_presult() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mkdir_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Mkdir_Presplit_args__isset {
    _MetadataIndexService_Mkdir_Presplit_args__isset() : obj_id(false), perm(false), hint_server1(false), hint_server2(false) {}
    bool obj_id :1;
    bool perm :1;
    bool hint_server1 :1;
    bool hint_server2 :1;
  } _MetadataIndexService_Mkdir_Presplit_args__isset;
  
  class MetadataIndexService_Mkdir_Presplit_args {
   public:
  
    MetadataIndexService_Mkdir_Presplit_args(const MetadataIndexService_Mkdir_Presplit_args&);
    MetadataIndexService_Mkdir_Presplit_args& operator=(const MetadataIndexService_Mkdir_Presplit_args&);
    MetadataIndexService_Mkdir_Presplit_args() : perm(0), hint_server1(0), hint_server2(0) {
    }
  
    virtual ~MetadataIndexService_Mkdir_Presplit_args() throw();
    OID obj_id;
    int16_t perm;
    int16_t hint_server1;
    int16_t hint_server2;
  
    _MetadataIndexService_Mkdir_Presplit_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    void __set_perm(const int16_t val);
  
    void __set_hint_server1(const int16_t val);
  
    void __set_hint_server2(const int16_t val);
  
    bool operator == (const MetadataIndexService_Mkdir_Presplit_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      if (!(perm == rhs.perm))
        return false;
      if (!(hint_server1 == rhs.hint_server1))
        return false;
      if (!(hint_server2 == rhs.hint_server2))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mkdir_Presplit_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mkdir_Presplit_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Mkdir_Presplit_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Mkdir_Presplit_pargs() throw();
    const OID* obj_id;
    const int16_t* perm;
    const int16_t* hint_server1;
    const int16_t* hint_server2;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mkdir_Presplit_result__isset {
    _MetadataIndexService_Mkdir_Presplit_result__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mkdir_Presplit_result__isset;
  
  class MetadataIndexService_Mkdir_Presplit_result {
   public:
  
    MetadataIndexService_Mkdir_Presplit_result(const MetadataIndexService_Mkdir_Presplit_result&);
    MetadataIndexService_Mkdir_Presplit_result& operator=(const MetadataIndexService_Mkdir_Presplit_result&);
    MetadataIndexService_Mkdir_Presplit_result() {
    }
  
    virtual ~MetadataIndexService_Mkdir_Presplit_result() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mkdir_Presplit_result__isset __isset;
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_file_exists(const FileAlreadyExistsException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Mkdir_Presplit_result & rhs) const
    {
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(file_exists == rhs.file_exists))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Mkdir_Presplit_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Mkdir_Presplit_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Mkdir_Presplit_presult__isset {
    _MetadataIndexService_Mkdir_Presplit_presult__isset() : unknown_dir(false), srv_redirect(false), file_exists(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Mkdir_Presplit_presult__isset;
  
  class MetadataIndexService_Mkdir_Presplit_presult {
   public:
  
  
    virtual ~MetadataIndexService_Mkdir_Presplit_presult() throw();
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Mkdir_Presplit_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Chmod_args__isset {
    _MetadataIndexService_Chmod_args__isset() : obj_id(false), perm(false) {}
    bool obj_id :1;
    bool perm :1;
  } _MetadataIndexService_Chmod_args__isset;
  
  class MetadataIndexService_Chmod_args {
   public:
  
    MetadataIndexService_Chmod_args(const MetadataIndexService_Chmod_args&);
    MetadataIndexService_Chmod_args& operator=(const MetadataIndexService_Chmod_args&);
    MetadataIndexService_Chmod_args() : perm(0) {
    }
  
    virtual ~MetadataIndexService_Chmod_args() throw();
    OID obj_id;
    int16_t perm;
  
    _MetadataIndexService_Chmod_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    void __set_perm(const int16_t val);
  
    bool operator == (const MetadataIndexService_Chmod_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      if (!(perm == rhs.perm))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Chmod_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Chmod_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Chmod_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Chmod_pargs() throw();
    const OID* obj_id;
    const int16_t* perm;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Chmod_result__isset {
    _MetadataIndexService_Chmod_result__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Chmod_result__isset;
  
  class MetadataIndexService_Chmod_result {
   public:
  
    MetadataIndexService_Chmod_result(const MetadataIndexService_Chmod_result&);
    MetadataIndexService_Chmod_result& operator=(const MetadataIndexService_Chmod_result&);
    MetadataIndexService_Chmod_result() : success(0) {
    }
  
    virtual ~MetadataIndexService_Chmod_result() throw();
    bool success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Chmod_result__isset __isset;
  
    void __set_success(const bool val);
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_not_found(const FileNotFoundException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Chmod_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(not_found == rhs.not_found))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Chmod_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Chmod_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Chmod_presult__isset {
    _MetadataIndexService_Chmod_presult__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Chmod_presult__isset;
  
  class MetadataIndexService_Chmod_presult {
   public:
  
  
    virtual ~MetadataIndexService_Chmod_presult() throw();
    bool* success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Chmod_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Chown_args__isset {
    _MetadataIndexService_Chown_args__isset() : obj_id(false), uid(false), gid(false) {}
    bool obj_id :1;
    bool uid :1;
    bool gid :1;
  } _MetadataIndexService_Chown_args__isset;
  
  class MetadataIndexService_Chown_args {
   public:
  
    MetadataIndexService_Chown_args(const MetadataIndexService_Chown_args&);
    MetadataIndexService_Chown_args& operator=(const MetadataIndexService_Chown_args&);
    MetadataIndexService_Chown_args() : uid(0), gid(0) {
    }
  
    virtual ~MetadataIndexService_Chown_args() throw();
    OID obj_id;
    int16_t uid;
    int16_t gid;
  
    _MetadataIndexService_Chown_args__isset __isset;
  
    void __set_obj_id(const OID& val);
  
    void __set_uid(const int16_t val);
  
    void __set_gid(const int16_t val);
  
    bool operator == (const MetadataIndexService_Chown_args & rhs) const
    {
      if (!(obj_id == rhs.obj_id))
        return false;
      if (!(uid == rhs.uid))
        return false;
      if (!(gid == rhs.gid))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Chown_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Chown_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Chown_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Chown_pargs() throw();
    const OID* obj_id;
    const int16_t* uid;
    const int16_t* gid;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Chown_result__isset {
    _MetadataIndexService_Chown_result__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Chown_result__isset;
  
  class MetadataIndexService_Chown_result {
   public:
  
    MetadataIndexService_Chown_result(const MetadataIndexService_Chown_result&);
    MetadataIndexService_Chown_result& operator=(const MetadataIndexService_Chown_result&);
    MetadataIndexService_Chown_result() : success(0) {
    }
  
    virtual ~MetadataIndexService_Chown_result() throw();
    bool success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Chown_result__isset __isset;
  
    void __set_success(const bool val);
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_srv_redirect(const ServerRedirectionException& val);
  
    void __set_not_found(const FileNotFoundException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Chown_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(srv_redirect == rhs.srv_redirect))
        return false;
      if (!(not_found == rhs.not_found))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Chown_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Chown_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Chown_presult__isset {
    _MetadataIndexService_Chown_presult__isset() : success(false), unknown_dir(false), srv_redirect(false), not_found(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool srv_redirect :1;
    bool not_found :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Chown_presult__isset;
  
  class MetadataIndexService_Chown_presult {
   public:
  
  
    virtual ~MetadataIndexService_Chown_presult() throw();
    bool* success;
    UnrecognizedDirectoryError unknown_dir;
    ServerRedirectionException srv_redirect;
    FileNotFoundException not_found;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Chown_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_CreateZeroth_args__isset {
    _MetadataIndexService_CreateZeroth_args__isset() : dir_id(false), zeroth_server(false) {}
    bool dir_id :1;
    bool zeroth_server :1;
  } _MetadataIndexService_CreateZeroth_args__isset;
  
  class MetadataIndexService_CreateZeroth_args {
   public:
  
    MetadataIndexService_CreateZeroth_args(const MetadataIndexService_CreateZeroth_args&);
    MetadataIndexService_CreateZeroth_args& operator=(const MetadataIndexService_CreateZeroth_args&);
    MetadataIndexService_CreateZeroth_args() : dir_id(0), zeroth_server(0) {
    }
  
    virtual ~MetadataIndexService_CreateZeroth_args() throw();
    int64_t dir_id;
    int16_t zeroth_server;
  
    _MetadataIndexService_CreateZeroth_args__isset __isset;
  
    void __set_dir_id(const int64_t val);
  
    void __set_zeroth_server(const int16_t val);
  
    bool operator == (const MetadataIndexService_CreateZeroth_args & rhs) const
    {
      if (!(dir_id == rhs.dir_id))
        return false;
      if (!(zeroth_server == rhs.zeroth_server))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_CreateZeroth_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_CreateZeroth_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_CreateZeroth_pargs {
   public:
  
  
    virtual ~MetadataIndexService_CreateZeroth_pargs() throw();
    const int64_t* dir_id;
    const int16_t* zeroth_server;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_CreateZeroth_result__isset {
    _MetadataIndexService_CreateZeroth_result__isset() : wrong_srv(false), file_exists(false), io_error(false), srv_error(false) {}
    bool wrong_srv :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_CreateZeroth_result__isset;
  
  class MetadataIndexService_CreateZeroth_result {
   public:
  
    MetadataIndexService_CreateZeroth_result(const MetadataIndexService_CreateZeroth_result&);
    MetadataIndexService_CreateZeroth_result& operator=(const MetadataIndexService_CreateZeroth_result&);
    MetadataIndexService_CreateZeroth_result() {
    }
  
    virtual ~MetadataIndexService_CreateZeroth_result() throw();
    WrongServerError wrong_srv;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_CreateZeroth_result__isset __isset;
  
    void __set_wrong_srv(const WrongServerError& val);
  
    void __set_file_exists(const FileAlreadyExistsException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_CreateZeroth_result & rhs) const
    {
      if (!(wrong_srv == rhs.wrong_srv))
        return false;
      if (!(file_exists == rhs.file_exists))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_CreateZeroth_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_CreateZeroth_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_CreateZeroth_presult__isset {
    _MetadataIndexService_CreateZeroth_presult__isset() : wrong_srv(false), file_exists(false), io_error(false), srv_error(false) {}
    bool wrong_srv :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_CreateZeroth_presult__isset;
  
  class MetadataIndexService_CreateZeroth_presult {
   public:
  
  
    virtual ~MetadataIndexService_CreateZeroth_presult() throw();
    WrongServerError wrong_srv;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_CreateZeroth_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_Readdir_args__isset {
    _MetadataIndexService_Readdir_args__isset() : dir_id(false), index(false) {}
    bool dir_id :1;
    bool index :1;
  } _MetadataIndexService_Readdir_args__isset;
  
  class MetadataIndexService_Readdir_args {
   public:
  
    MetadataIndexService_Readdir_args(const MetadataIndexService_Readdir_args&);
    MetadataIndexService_Readdir_args& operator=(const MetadataIndexService_Readdir_args&);
    MetadataIndexService_Readdir_args() : dir_id(0), index(0) {
    }
  
    virtual ~MetadataIndexService_Readdir_args() throw();
    int64_t dir_id;
    int16_t index;
  
    _MetadataIndexService_Readdir_args__isset __isset;
  
    void __set_dir_id(const int64_t val);
  
    void __set_index(const int16_t val);
  
    bool operator == (const MetadataIndexService_Readdir_args & rhs) const
    {
      if (!(dir_id == rhs.dir_id))
        return false;
      if (!(index == rhs.index))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Readdir_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Readdir_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_Readdir_pargs {
   public:
  
  
    virtual ~MetadataIndexService_Readdir_pargs() throw();
    const int64_t* dir_id;
    const int16_t* index;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Readdir_result__isset {
    _MetadataIndexService_Readdir_result__isset() : success(false), unknown_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Readdir_result__isset;
  
  class MetadataIndexService_Readdir_result {
   public:
  
    MetadataIndexService_Readdir_result(const MetadataIndexService_Readdir_result&);
    MetadataIndexService_Readdir_result& operator=(const MetadataIndexService_Readdir_result&);
    MetadataIndexService_Readdir_result() {
    }
  
    virtual ~MetadataIndexService_Readdir_result() throw();
    EntryList success;
    UnrecognizedDirectoryError unknown_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Readdir_result__isset __isset;
  
    void __set_success(const EntryList& val);
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_Readdir_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_Readdir_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_Readdir_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_Readdir_presult__isset {
    _MetadataIndexService_Readdir_presult__isset() : success(false), unknown_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_Readdir_presult__isset;
  
  class MetadataIndexService_Readdir_presult {
   public:
  
  
    virtual ~MetadataIndexService_Readdir_presult() throw();
    EntryList* success;
    UnrecognizedDirectoryError unknown_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_Readdir_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_ReadBitmap_args__isset {
    _MetadataIndexService_ReadBitmap_args__isset() : dir_id(false) {}
    bool dir_id :1;
  } _MetadataIndexService_ReadBitmap_args__isset;
  
  class MetadataIndexService_ReadBitmap_args {
   public:
  
    MetadataIndexService_ReadBitmap_args(const MetadataIndexService_ReadBitmap_args&);
    MetadataIndexService_ReadBitmap_args& operator=(const MetadataIndexService_ReadBitmap_args&);
    MetadataIndexService_ReadBitmap_args() : dir_id(0) {
    }
  
    virtual ~MetadataIndexService_ReadBitmap_args() throw();
    int64_t dir_id;
  
    _MetadataIndexService_ReadBitmap_args__isset __isset;
  
    void __set_dir_id(const int64_t val);
  
    bool operator == (const MetadataIndexService_ReadBitmap_args & rhs) const
    {
      if (!(dir_id == rhs.dir_id))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_ReadBitmap_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_ReadBitmap_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_ReadBitmap_pargs {
   public:
  
  
    virtual ~MetadataIndexService_ReadBitmap_pargs() throw();
    const int64_t* dir_id;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_ReadBitmap_result__isset {
    _MetadataIndexService_ReadBitmap_result__isset() : success(false), unknown_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_ReadBitmap_result__isset;
  
  class MetadataIndexService_ReadBitmap_result {
   public:
  
    MetadataIndexService_ReadBitmap_result(const MetadataIndexService_ReadBitmap_result&);
    MetadataIndexService_ReadBitmap_result& operator=(const MetadataIndexService_ReadBitmap_result&);
    MetadataIndexService_ReadBitmap_result() : success() {
    }
  
    virtual ~MetadataIndexService_ReadBitmap_result() throw();
    std::string success;
    UnrecognizedDirectoryError unknown_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_ReadBitmap_result__isset __isset;
  
    void __set_success(const std::string& val);
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_ReadBitmap_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_ReadBitmap_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_ReadBitmap_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_ReadBitmap_presult__isset {
    _MetadataIndexService_ReadBitmap_presult__isset() : success(false), unknown_dir(false), io_error(false), srv_error(false) {}
    bool success :1;
    bool unknown_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_ReadBitmap_presult__isset;
  
  class MetadataIndexService_ReadBitmap_presult {
   public:
  
  
    virtual ~MetadataIndexService_ReadBitmap_presult() throw();
    std::string* success;
    UnrecognizedDirectoryError unknown_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_ReadBitmap_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_UpdateBitmap_args__isset {
    _MetadataIndexService_UpdateBitmap_args__isset() : dir_id(false), dmap_data(false) {}
    bool dir_id :1;
    bool dmap_data :1;
  } _MetadataIndexService_UpdateBitmap_args__isset;
  
  class MetadataIndexService_UpdateBitmap_args {
   public:
  
    MetadataIndexService_UpdateBitmap_args(const MetadataIndexService_UpdateBitmap_args&);
    MetadataIndexService_UpdateBitmap_args& operator=(const MetadataIndexService_UpdateBitmap_args&);
    MetadataIndexService_UpdateBitmap_args() : dir_id(0), dmap_data() {
    }
  
    virtual ~MetadataIndexService_UpdateBitmap_args() throw();
    int64_t dir_id;
    std::string dmap_data;
  
    _MetadataIndexService_UpdateBitmap_args__isset __isset;
  
    void __set_dir_id(const int64_t val);
  
    void __set_dmap_data(const std::string& val);
  
    bool operator == (const MetadataIndexService_UpdateBitmap_args & rhs) const
    {
      if (!(dir_id == rhs.dir_id))
        return false;
      if (!(dmap_data == rhs.dmap_data))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_UpdateBitmap_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_UpdateBitmap_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_UpdateBitmap_pargs {
   public:
  
  
    virtual ~MetadataIndexService_UpdateBitmap_pargs() throw();
    const int64_t* dir_id;
    const std::string* dmap_data;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_UpdateBitmap_result__isset {
    _MetadataIndexService_UpdateBitmap_result__isset() : unknown_dir(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_UpdateBitmap_result__isset;
  
  class MetadataIndexService_UpdateBitmap_result {
   public:
  
    MetadataIndexService_UpdateBitmap_result(const MetadataIndexService_UpdateBitmap_result&);
    MetadataIndexService_UpdateBitmap_result& operator=(const MetadataIndexService_UpdateBitmap_result&);
    MetadataIndexService_UpdateBitmap_result() {
    }
  
    virtual ~MetadataIndexService_UpdateBitmap_result() throw();
    UnrecognizedDirectoryError unknown_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_UpdateBitmap_result__isset __isset;
  
    void __set_unknown_dir(const UnrecognizedDirectoryError& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_UpdateBitmap_result & rhs) const
    {
      if (!(unknown_dir == rhs.unknown_dir))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_UpdateBitmap_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_UpdateBitmap_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_UpdateBitmap_presult__isset {
    _MetadataIndexService_UpdateBitmap_presult__isset() : unknown_dir(false), io_error(false), srv_error(false) {}
    bool unknown_dir :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_UpdateBitmap_presult__isset;
  
  class MetadataIndexService_UpdateBitmap_presult {
   public:
  
  
    virtual ~MetadataIndexService_UpdateBitmap_presult() throw();
    UnrecognizedDirectoryError unknown_dir;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_UpdateBitmap_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MetadataIndexService_InsertSplit_args__isset {
    _MetadataIndexService_InsertSplit_args__isset() : dir_id(false), parent_index(false), child_index(false), path_split_files(false), dmap_data(false), min_seq(false), max_seq(false), num_entries(false) {}
    bool dir_id :1;
    bool parent_index :1;
    bool child_index :1;
    bool path_split_files :1;
    bool dmap_data :1;
    bool min_seq :1;
    bool max_seq :1;
    bool num_entries :1;
  } _MetadataIndexService_InsertSplit_args__isset;
  
  class MetadataIndexService_InsertSplit_args {
   public:
  
    MetadataIndexService_InsertSplit_args(const MetadataIndexService_InsertSplit_args&);
    MetadataIndexService_InsertSplit_args& operator=(const MetadataIndexService_InsertSplit_args&);
    MetadataIndexService_InsertSplit_args() : dir_id(0), parent_index(0), child_index(0), path_split_files(), dmap_data(), min_seq(0), max_seq(0), num_entries(0) {
    }
  
    virtual ~MetadataIndexService_InsertSplit_args() throw();
    int64_t dir_id;
    int16_t parent_index;
    int16_t child_index;
    std::string path_split_files;
    std::string dmap_data;
    int64_t min_seq;
    int64_t max_seq;
    int64_t num_entries;
  
    _MetadataIndexService_InsertSplit_args__isset __isset;
  
    void __set_dir_id(const int64_t val);
  
    void __set_parent_index(const int16_t val);
  
    void __set_child_index(const int16_t val);
  
    void __set_path_split_files(const std::string& val);
  
    void __set_dmap_data(const std::string& val);
  
    void __set_min_seq(const int64_t val);
  
    void __set_max_seq(const int64_t val);
  
    void __set_num_entries(const int64_t val);
  
    bool operator == (const MetadataIndexService_InsertSplit_args & rhs) const
    {
      if (!(dir_id == rhs.dir_id))
        return false;
      if (!(parent_index == rhs.parent_index))
        return false;
      if (!(child_index == rhs.child_index))
        return false;
      if (!(path_split_files == rhs.path_split_files))
        return false;
      if (!(dmap_data == rhs.dmap_data))
        return false;
      if (!(min_seq == rhs.min_seq))
        return false;
      if (!(max_seq == rhs.max_seq))
        return false;
      if (!(num_entries == rhs.num_entries))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_InsertSplit_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_InsertSplit_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MetadataIndexService_InsertSplit_pargs {
   public:
  
  
    virtual ~MetadataIndexService_InsertSplit_pargs() throw();
    const int64_t* dir_id;
    const int16_t* parent_index;
    const int16_t* child_index;
    const std::string* path_split_files;
    const std::string* dmap_data;
    const int64_t* min_seq;
    const int64_t* max_seq;
    const int64_t* num_entries;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_InsertSplit_result__isset {
    _MetadataIndexService_InsertSplit_result__isset() : wrong_srv(false), file_exists(false), io_error(false), srv_error(false) {}
    bool wrong_srv :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_InsertSplit_result__isset;
  
  class MetadataIndexService_InsertSplit_result {
   public:
  
    MetadataIndexService_InsertSplit_result(const MetadataIndexService_InsertSplit_result&);
    MetadataIndexService_InsertSplit_result& operator=(const MetadataIndexService_InsertSplit_result&);
    MetadataIndexService_InsertSplit_result() {
    }
  
    virtual ~MetadataIndexService_InsertSplit_result() throw();
    WrongServerError wrong_srv;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_InsertSplit_result__isset __isset;
  
    void __set_wrong_srv(const WrongServerError& val);
  
    void __set_file_exists(const FileAlreadyExistsException& val);
  
    void __set_io_error(const IOError& val);
  
    void __set_srv_error(const ServerInternalError& val);
  
    bool operator == (const MetadataIndexService_InsertSplit_result & rhs) const
    {
      if (!(wrong_srv == rhs.wrong_srv))
        return false;
      if (!(file_exists == rhs.file_exists))
        return false;
      if (!(io_error == rhs.io_error))
        return false;
      if (!(srv_error == rhs.srv_error))
        return false;
      return true;
    }
    bool operator != (const MetadataIndexService_InsertSplit_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MetadataIndexService_InsertSplit_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MetadataIndexService_InsertSplit_presult__isset {
    _MetadataIndexService_InsertSplit_presult__isset() : wrong_srv(false), file_exists(false), io_error(false), srv_error(false) {}
    bool wrong_srv :1;
    bool file_exists :1;
    bool io_error :1;
    bool srv_error :1;
  } _MetadataIndexService_InsertSplit_presult__isset;
  
  class MetadataIndexService_InsertSplit_presult {
   public:
  
  
    virtual ~MetadataIndexService_InsertSplit_presult() throw();
    WrongServerError wrong_srv;
    FileAlreadyExistsException file_exists;
    IOError io_error;
    ServerInternalError srv_error;
  
    _MetadataIndexService_InsertSplit_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  class MetadataIndexServiceClient : virtual public MetadataIndexServiceIf {
   public:
    MetadataIndexServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
      setProtocol(prot);
    }
    MetadataIndexServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
      setProtocol(iprot,oprot);
    }
   private:
    void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot,prot);
    }
    void setProtocol(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();
    }
   public:
    boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
      return piprot_;
    }
    boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
      return poprot_;
    }
    void Ping();
    void send_Ping();
    void recv_Ping();
    void FlushDB();
    void send_FlushDB();
    void recv_FlushDB();
    void Access(LookupInfo& _return, const OID& obj_id);
    void send_Access(const OID& obj_id);
    void recv_Access(LookupInfo& _return);
    void Renew(LookupInfo& _return, const OID& obj_id);
    void send_Renew(const OID& obj_id);
    void recv_Renew(LookupInfo& _return);
    void Getattr(StatInfo& _return, const OID& obj_id);
    void send_Getattr(const OID& obj_id);
    void recv_Getattr(StatInfo& _return);
    void Mknod(const OID& obj_id, const int16_t perm);
    void send_Mknod(const OID& obj_id, const int16_t perm);
    void recv_Mknod();
    void Mknod_Bulk(const OIDS& obj_ids, const int16_t perm);
    void send_Mknod_Bulk(const OIDS& obj_ids, const int16_t perm);
    void recv_Mknod_Bulk();
    void Mkdir(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    void send_Mkdir(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    void recv_Mkdir();
    void Mkdir_Presplit(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    void send_Mkdir_Presplit(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    void recv_Mkdir_Presplit();
    bool Chmod(const OID& obj_id, const int16_t perm);
    void send_Chmod(const OID& obj_id, const int16_t perm);
    bool recv_Chmod();
    bool Chown(const OID& obj_id, const int16_t uid, const int16_t gid);
    void send_Chown(const OID& obj_id, const int16_t uid, const int16_t gid);
    bool recv_Chown();
    void CreateZeroth(const int64_t dir_id, const int16_t zeroth_server);
    void send_CreateZeroth(const int64_t dir_id, const int16_t zeroth_server);
    void recv_CreateZeroth();
    void Readdir(EntryList& _return, const int64_t dir_id, const int16_t index);
    void send_Readdir(const int64_t dir_id, const int16_t index);
    void recv_Readdir(EntryList& _return);
    void ReadBitmap(std::string& _return, const int64_t dir_id);
    void send_ReadBitmap(const int64_t dir_id);
    void recv_ReadBitmap(std::string& _return);
    void UpdateBitmap(const int64_t dir_id, const std::string& dmap_data);
    void send_UpdateBitmap(const int64_t dir_id, const std::string& dmap_data);
    void recv_UpdateBitmap();
    void InsertSplit(const int64_t dir_id, const int16_t parent_index, const int16_t child_index, const std::string& path_split_files, const std::string& dmap_data, const int64_t min_seq, const int64_t max_seq, const int64_t num_entries);
    void send_InsertSplit(const int64_t dir_id, const int16_t parent_index, const int16_t child_index, const std::string& path_split_files, const std::string& dmap_data, const int64_t min_seq, const int64_t max_seq, const int64_t num_entries);
    void recv_InsertSplit();
   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 MetadataIndexServiceProcessor : public ::apache::thrift::TDispatchProcessor {
   protected:
    boost::shared_ptr<MetadataIndexServiceIf> iface_;
    virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
   private:
    typedef  void (MetadataIndexServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
    typedef std::map<std::string, ProcessFunction> ProcessMap;
    ProcessMap processMap_;
    void process_Ping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_FlushDB(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Access(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Renew(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Getattr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Mknod(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Mknod_Bulk(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Mkdir(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Mkdir_Presplit(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Chmod(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Chown(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_CreateZeroth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_Readdir(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_ReadBitmap(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_UpdateBitmap(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_InsertSplit(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   public:
    MetadataIndexServiceProcessor(boost::shared_ptr<MetadataIndexServiceIf> iface) :
      iface_(iface) {
      processMap_["Ping"] = &MetadataIndexServiceProcessor::process_Ping;
      processMap_["FlushDB"] = &MetadataIndexServiceProcessor::process_FlushDB;
      processMap_["Access"] = &MetadataIndexServiceProcessor::process_Access;
      processMap_["Renew"] = &MetadataIndexServiceProcessor::process_Renew;
      processMap_["Getattr"] = &MetadataIndexServiceProcessor::process_Getattr;
      processMap_["Mknod"] = &MetadataIndexServiceProcessor::process_Mknod;
      processMap_["Mknod_Bulk"] = &MetadataIndexServiceProcessor::process_Mknod_Bulk;
      processMap_["Mkdir"] = &MetadataIndexServiceProcessor::process_Mkdir;
      processMap_["Mkdir_Presplit"] = &MetadataIndexServiceProcessor::process_Mkdir_Presplit;
      processMap_["Chmod"] = &MetadataIndexServiceProcessor::process_Chmod;
      processMap_["Chown"] = &MetadataIndexServiceProcessor::process_Chown;
      processMap_["CreateZeroth"] = &MetadataIndexServiceProcessor::process_CreateZeroth;
      processMap_["Readdir"] = &MetadataIndexServiceProcessor::process_Readdir;
      processMap_["ReadBitmap"] = &MetadataIndexServiceProcessor::process_ReadBitmap;
      processMap_["UpdateBitmap"] = &MetadataIndexServiceProcessor::process_UpdateBitmap;
      processMap_["InsertSplit"] = &MetadataIndexServiceProcessor::process_InsertSplit;
    }
  
    virtual ~MetadataIndexServiceProcessor() {}
  };
  
  class MetadataIndexServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
   public:
    MetadataIndexServiceProcessorFactory(const ::boost::shared_ptr< MetadataIndexServiceIfFactory >& handlerFactory) :
        handlerFactory_(handlerFactory) {}
  
    ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
  
   protected:
    ::boost::shared_ptr< MetadataIndexServiceIfFactory > handlerFactory_;
  };
  
  class MetadataIndexServiceMultiface : virtual public MetadataIndexServiceIf {
   public:
    MetadataIndexServiceMultiface(std::vector<boost::shared_ptr<MetadataIndexServiceIf> >& ifaces) : ifaces_(ifaces) {
    }
    virtual ~MetadataIndexServiceMultiface() {}
   protected:
    std::vector<boost::shared_ptr<MetadataIndexServiceIf> > ifaces_;
    MetadataIndexServiceMultiface() {}
    void add(boost::shared_ptr<MetadataIndexServiceIf> iface) {
      ifaces_.push_back(iface);
    }
   public:
    void Ping() {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Ping();
      }
      ifaces_[i]->Ping();
    }
  
    void FlushDB() {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->FlushDB();
      }
      ifaces_[i]->FlushDB();
    }
  
    void Access(LookupInfo& _return, const OID& obj_id) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Access(_return, obj_id);
      }
      ifaces_[i]->Access(_return, obj_id);
      return;
    }
  
    void Renew(LookupInfo& _return, const OID& obj_id) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Renew(_return, obj_id);
      }
      ifaces_[i]->Renew(_return, obj_id);
      return;
    }
  
    void Getattr(StatInfo& _return, const OID& obj_id) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Getattr(_return, obj_id);
      }
      ifaces_[i]->Getattr(_return, obj_id);
      return;
    }
  
    void Mknod(const OID& obj_id, const int16_t perm) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Mknod(obj_id, perm);
      }
      ifaces_[i]->Mknod(obj_id, perm);
    }
  
    void Mknod_Bulk(const OIDS& obj_ids, const int16_t perm) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Mknod_Bulk(obj_ids, perm);
      }
      ifaces_[i]->Mknod_Bulk(obj_ids, perm);
    }
  
    void Mkdir(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Mkdir(obj_id, perm, hint_server1, hint_server2);
      }
      ifaces_[i]->Mkdir(obj_id, perm, hint_server1, hint_server2);
    }
  
    void Mkdir_Presplit(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Mkdir_Presplit(obj_id, perm, hint_server1, hint_server2);
      }
      ifaces_[i]->Mkdir_Presplit(obj_id, perm, hint_server1, hint_server2);
    }
  
    bool Chmod(const OID& obj_id, const int16_t perm) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Chmod(obj_id, perm);
      }
      return ifaces_[i]->Chmod(obj_id, perm);
    }
  
    bool Chown(const OID& obj_id, const int16_t uid, const int16_t gid) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Chown(obj_id, uid, gid);
      }
      return ifaces_[i]->Chown(obj_id, uid, gid);
    }
  
    void CreateZeroth(const int64_t dir_id, const int16_t zeroth_server) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->CreateZeroth(dir_id, zeroth_server);
      }
      ifaces_[i]->CreateZeroth(dir_id, zeroth_server);
    }
  
    void Readdir(EntryList& _return, const int64_t dir_id, const int16_t index) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->Readdir(_return, dir_id, index);
      }
      ifaces_[i]->Readdir(_return, dir_id, index);
      return;
    }
  
    void ReadBitmap(std::string& _return, const int64_t dir_id) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->ReadBitmap(_return, dir_id);
      }
      ifaces_[i]->ReadBitmap(_return, dir_id);
      return;
    }
  
    void UpdateBitmap(const int64_t dir_id, const std::string& dmap_data) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->UpdateBitmap(dir_id, dmap_data);
      }
      ifaces_[i]->UpdateBitmap(dir_id, dmap_data);
    }
  
    void InsertSplit(const int64_t dir_id, const int16_t parent_index, const int16_t child_index, const std::string& path_split_files, const std::string& dmap_data, const int64_t min_seq, const int64_t max_seq, const int64_t num_entries) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->InsertSplit(dir_id, parent_index, child_index, path_split_files, dmap_data, min_seq, max_seq, num_entries);
      }
      ifaces_[i]->InsertSplit(dir_id, parent_index, child_index, path_split_files, dmap_data, min_seq, max_seq, num_entries);
    }
  
  };
  
  // 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
  class MetadataIndexServiceConcurrentClient : virtual public MetadataIndexServiceIf {
   public:
    MetadataIndexServiceConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
      setProtocol(prot);
    }
    MetadataIndexServiceConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
      setProtocol(iprot,oprot);
    }
   private:
    void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot,prot);
    }
    void setProtocol(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();
    }
   public:
    boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
      return piprot_;
    }
    boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
      return poprot_;
    }
    void Ping();
    int32_t send_Ping();
    void recv_Ping(const int32_t seqid);
    void FlushDB();
    int32_t send_FlushDB();
    void recv_FlushDB(const int32_t seqid);
    void Access(LookupInfo& _return, const OID& obj_id);
    int32_t send_Access(const OID& obj_id);
    void recv_Access(LookupInfo& _return, const int32_t seqid);
    void Renew(LookupInfo& _return, const OID& obj_id);
    int32_t send_Renew(const OID& obj_id);
    void recv_Renew(LookupInfo& _return, const int32_t seqid);
    void Getattr(StatInfo& _return, const OID& obj_id);
    int32_t send_Getattr(const OID& obj_id);
    void recv_Getattr(StatInfo& _return, const int32_t seqid);
    void Mknod(const OID& obj_id, const int16_t perm);
    int32_t send_Mknod(const OID& obj_id, const int16_t perm);
    void recv_Mknod(const int32_t seqid);
    void Mknod_Bulk(const OIDS& obj_ids, const int16_t perm);
    int32_t send_Mknod_Bulk(const OIDS& obj_ids, const int16_t perm);
    void recv_Mknod_Bulk(const int32_t seqid);
    void Mkdir(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    int32_t send_Mkdir(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    void recv_Mkdir(const int32_t seqid);
    void Mkdir_Presplit(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    int32_t send_Mkdir_Presplit(const OID& obj_id, const int16_t perm, const int16_t hint_server1, const int16_t hint_server2);
    void recv_Mkdir_Presplit(const int32_t seqid);
    bool Chmod(const OID& obj_id, const int16_t perm);
    int32_t send_Chmod(const OID& obj_id, const int16_t perm);
    bool recv_Chmod(const int32_t seqid);
    bool Chown(const OID& obj_id, const int16_t uid, const int16_t gid);
    int32_t send_Chown(const OID& obj_id, const int16_t uid, const int16_t gid);
    bool recv_Chown(const int32_t seqid);
    void CreateZeroth(const int64_t dir_id, const int16_t zeroth_server);
    int32_t send_CreateZeroth(const int64_t dir_id, const int16_t zeroth_server);
    void recv_CreateZeroth(const int32_t seqid);
    void Readdir(EntryList& _return, const int64_t dir_id, const int16_t index);
    int32_t send_Readdir(const int64_t dir_id, const int16_t index);
    void recv_Readdir(EntryList& _return, const int32_t seqid);
    void ReadBitmap(std::string& _return, const int64_t dir_id);
    int32_t send_ReadBitmap(const int64_t dir_id);
    void recv_ReadBitmap(std::string& _return, const int32_t seqid);
    void UpdateBitmap(const int64_t dir_id, const std::string& dmap_data);
    int32_t send_UpdateBitmap(const int64_t dir_id, const std::string& dmap_data);
    void recv_UpdateBitmap(const int32_t seqid);
    void InsertSplit(const int64_t dir_id, const int16_t parent_index, const int16_t child_index, const std::string& path_split_files, const std::string& dmap_data, const int64_t min_seq, const int64_t max_seq, const int64_t num_entries);
    int32_t send_InsertSplit(const int64_t dir_id, const int16_t parent_index, const int16_t child_index, const std::string& path_split_files, const std::string& dmap_data, const int64_t min_seq, const int64_t max_seq, const int64_t num_entries);
    void recv_InsertSplit(const int32_t seqid);
   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_;
    ::apache::thrift::async::TConcurrentClientSyncInfo sync_;
  };
  
  #ifdef _WIN32
    #pragma warning( pop )
  #endif
  
  } // namespace
  
  #endif
  