// -*-c++-*-
/* This file was automatically generated by rpcc. */

#ifndef __RPCC_NFS3EXP_PROT_H_INCLUDED__
#define __RPCC_NFS3EXP_PROT_H_INCLUDED__ 1

#include "xdrmisc.h"
#include "nfs3_prot.h"


struct ex_fattr3 {
  ftype3 type;
  uint32 mode;
  uint32 nlink;
  uint32 uid;
  uint32 gid;
  uint64 size;
  uint64 used;
  specdata3 rdev;
  uint64 fsid;
  uint64 fileid;
  nfstime3 atime;
  nfstime3 mtime;
  nfstime3 ctime;
  uint32 expire;
};
void *ex_fattr3_alloc ();
bool_t xdr_ex_fattr3 (XDR *, void *);
RPC_STRUCT_DECL (ex_fattr3)

template<class T> bool
rpc_traverse (T &t, ex_fattr3 &obj)
{
  return rpc_traverse (t, obj.type)
    && rpc_traverse (t, obj.mode)
    && rpc_traverse (t, obj.nlink)
    && rpc_traverse (t, obj.uid)
    && rpc_traverse (t, obj.gid)
    && rpc_traverse (t, obj.size)
    && rpc_traverse (t, obj.used)
    && rpc_traverse (t, obj.rdev)
    && rpc_traverse (t, obj.fsid)
    && rpc_traverse (t, obj.fileid)
    && rpc_traverse (t, obj.atime)
    && rpc_traverse (t, obj.mtime)
    && rpc_traverse (t, obj.ctime)
    && rpc_traverse (t, obj.expire);
}



struct ex_post_op_attr {
  const bool present;
  union {
    union_entry_base _base;
    union_entry<ex_fattr3> attributes;
  };

#define rpcunion_tag_ex_post_op_attr present
#define rpcunion_switch_ex_post_op_attr(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case true: \
    action (ex_fattr3, attributes); \
    break; \
  case false: \
    voidaction; \
    break; \
  default: \
    defaction; \
    break; \
  }

  ex_post_op_attr (bool _tag = (bool) 0) : present (_tag)
    { _base.init (); set_present (_tag); }
  ex_post_op_attr (const ex_post_op_attr &_s)
    : present (_s.present)
    { _base.init (_s._base); }
  ~ex_post_op_attr () { _base.destroy (); }
  ex_post_op_attr &operator= (const ex_post_op_attr &_s) {
    const_cast<bool &> (present) = _s.present;
    _base.assign (_s._base);
    return *this;
  }

  void set_present (bool _tag) {
    const_cast<bool &> (present) = _tag;
    rpcunion_switch_ex_post_op_attr
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_post_op_attr &obj)
{
  bool tag = obj.present;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.present)
    obj.set_present (tag);

  rpcunion_switch_ex_post_op_attr
    (obj.present, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_post_op_attr &obj)
{
  rpcunion_switch_ex_post_op_attr
    (obj.present, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_post_op_attr_alloc ();
bool_t xdr_ex_post_op_attr (XDR *, void *);
RPC_UNION_DECL (ex_post_op_attr)



struct ex_wcc_data {
  pre_op_attr before;
  ex_post_op_attr after;
};
void *ex_wcc_data_alloc ();
bool_t xdr_ex_wcc_data (XDR *, void *);
RPC_STRUCT_DECL (ex_wcc_data)

template<class T> bool
rpc_traverse (T &t, ex_wcc_data &obj)
{
  return rpc_traverse (t, obj.before)
    && rpc_traverse (t, obj.after);
}



struct ex_diropres3ok {
  post_op_fh3 obj;
  ex_post_op_attr obj_attributes;
  ex_wcc_data dir_wcc;
};
void *ex_diropres3ok_alloc ();
bool_t xdr_ex_diropres3ok (XDR *, void *);
RPC_STRUCT_DECL (ex_diropres3ok)

template<class T> bool
rpc_traverse (T &t, ex_diropres3ok &obj)
{
  return rpc_traverse (t, obj.obj)
    && rpc_traverse (t, obj.obj_attributes)
    && rpc_traverse (t, obj.dir_wcc);
}



struct ex_diropres3 {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_diropres3ok> resok;
    union_entry<ex_wcc_data> resfail;
  };

#define rpcunion_tag_ex_diropres3 status
#define rpcunion_switch_ex_diropres3(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_diropres3ok, resok); \
    break; \
  default: \
    action (ex_wcc_data, resfail); \
    break; \
  }

  ex_diropres3 (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_diropres3 (const ex_diropres3 &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_diropres3 () { _base.destroy (); }
  ex_diropres3 &operator= (const ex_diropres3 &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_diropres3
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_diropres3 &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_diropres3
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_diropres3 &obj)
{
  rpcunion_switch_ex_diropres3
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_diropres3_alloc ();
bool_t xdr_ex_diropres3 (XDR *, void *);
RPC_UNION_DECL (ex_diropres3)



struct ex_wccstat3 {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_wcc_data> wcc;
  };

#define rpcunion_tag_ex_wccstat3 status
#define rpcunion_switch_ex_wccstat3(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  default: \
    action (ex_wcc_data, wcc); \
    break; \
  }

  ex_wccstat3 (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_wccstat3 (const ex_wccstat3 &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_wccstat3 () { _base.destroy (); }
  ex_wccstat3 &operator= (const ex_wccstat3 &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_wccstat3
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_wccstat3 &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_wccstat3
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_wccstat3 &obj)
{
  rpcunion_switch_ex_wccstat3
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_wccstat3_alloc ();
bool_t xdr_ex_wccstat3 (XDR *, void *);
RPC_UNION_DECL (ex_wccstat3)



struct ex_getattr3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_fattr3> attributes;
  };

#define rpcunion_tag_ex_getattr3res status
#define rpcunion_switch_ex_getattr3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_fattr3, attributes); \
    break; \
  default: \
    voidaction; \
    break; \
  }

  ex_getattr3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_getattr3res (const ex_getattr3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_getattr3res () { _base.destroy (); }
  ex_getattr3res &operator= (const ex_getattr3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_getattr3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_getattr3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_getattr3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_getattr3res &obj)
{
  rpcunion_switch_ex_getattr3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_getattr3res_alloc ();
bool_t xdr_ex_getattr3res (XDR *, void *);
RPC_UNION_DECL (ex_getattr3res)



struct ex_lookup3resok {
  nfs_fh3 object;
  ex_post_op_attr obj_attributes;
  ex_post_op_attr dir_attributes;
};
void *ex_lookup3resok_alloc ();
bool_t xdr_ex_lookup3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_lookup3resok)

template<class T> bool
rpc_traverse (T &t, ex_lookup3resok &obj)
{
  return rpc_traverse (t, obj.object)
    && rpc_traverse (t, obj.obj_attributes)
    && rpc_traverse (t, obj.dir_attributes);
}



struct ex_lookup3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_lookup3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_lookup3res status
#define rpcunion_switch_ex_lookup3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_lookup3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_lookup3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_lookup3res (const ex_lookup3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_lookup3res () { _base.destroy (); }
  ex_lookup3res &operator= (const ex_lookup3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_lookup3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_lookup3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_lookup3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_lookup3res &obj)
{
  rpcunion_switch_ex_lookup3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_lookup3res_alloc ();
bool_t xdr_ex_lookup3res (XDR *, void *);
RPC_UNION_DECL (ex_lookup3res)



struct ex_access3resok {
  ex_post_op_attr obj_attributes;
  uint32 access;
};
void *ex_access3resok_alloc ();
bool_t xdr_ex_access3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_access3resok)

template<class T> bool
rpc_traverse (T &t, ex_access3resok &obj)
{
  return rpc_traverse (t, obj.obj_attributes)
    && rpc_traverse (t, obj.access);
}



struct ex_access3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_access3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_access3res status
#define rpcunion_switch_ex_access3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_access3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_access3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_access3res (const ex_access3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_access3res () { _base.destroy (); }
  ex_access3res &operator= (const ex_access3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_access3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_access3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_access3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_access3res &obj)
{
  rpcunion_switch_ex_access3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_access3res_alloc ();
bool_t xdr_ex_access3res (XDR *, void *);
RPC_UNION_DECL (ex_access3res)



struct ex_readlink3resok {
  ex_post_op_attr symlink_attributes;
  nfspath3 data;
};
void *ex_readlink3resok_alloc ();
bool_t xdr_ex_readlink3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_readlink3resok)

template<class T> bool
rpc_traverse (T &t, ex_readlink3resok &obj)
{
  return rpc_traverse (t, obj.symlink_attributes)
    && rpc_traverse (t, obj.data);
}



struct ex_readlink3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_readlink3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_readlink3res status
#define rpcunion_switch_ex_readlink3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_readlink3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_readlink3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_readlink3res (const ex_readlink3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_readlink3res () { _base.destroy (); }
  ex_readlink3res &operator= (const ex_readlink3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_readlink3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_readlink3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_readlink3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_readlink3res &obj)
{
  rpcunion_switch_ex_readlink3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_readlink3res_alloc ();
bool_t xdr_ex_readlink3res (XDR *, void *);
RPC_UNION_DECL (ex_readlink3res)



struct ex_read3resok {
  ex_post_op_attr file_attributes;
  uint32 count;
  bool eof;
  rpc_bytes<RPC_INFINITY> data;
};
void *ex_read3resok_alloc ();
bool_t xdr_ex_read3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_read3resok)

template<class T> bool
rpc_traverse (T &t, ex_read3resok &obj)
{
  return rpc_traverse (t, obj.file_attributes)
    && rpc_traverse (t, obj.count)
    && rpc_traverse (t, obj.eof)
    && rpc_traverse (t, obj.data);
}



struct ex_read3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_read3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_read3res status
#define rpcunion_switch_ex_read3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_read3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_read3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_read3res (const ex_read3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_read3res () { _base.destroy (); }
  ex_read3res &operator= (const ex_read3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_read3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_read3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_read3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_read3res &obj)
{
  rpcunion_switch_ex_read3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_read3res_alloc ();
bool_t xdr_ex_read3res (XDR *, void *);
RPC_UNION_DECL (ex_read3res)



struct ex_write3resok {
  ex_wcc_data file_wcc;
  uint32 count;
  stable_how committed;
  writeverf3 verf;
};
void *ex_write3resok_alloc ();
bool_t xdr_ex_write3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_write3resok)

template<class T> bool
rpc_traverse (T &t, ex_write3resok &obj)
{
  return rpc_traverse (t, obj.file_wcc)
    && rpc_traverse (t, obj.count)
    && rpc_traverse (t, obj.committed)
    && rpc_traverse (t, obj.verf);
}



struct ex_write3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_write3resok> resok;
    union_entry<ex_wcc_data> resfail;
  };

#define rpcunion_tag_ex_write3res status
#define rpcunion_switch_ex_write3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_write3resok, resok); \
    break; \
  default: \
    action (ex_wcc_data, resfail); \
    break; \
  }

  ex_write3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_write3res (const ex_write3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_write3res () { _base.destroy (); }
  ex_write3res &operator= (const ex_write3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_write3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_write3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_write3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_write3res &obj)
{
  rpcunion_switch_ex_write3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_write3res_alloc ();
bool_t xdr_ex_write3res (XDR *, void *);
RPC_UNION_DECL (ex_write3res)



struct ex_rename3wcc {
  ex_wcc_data fromdir_wcc;
  ex_wcc_data todir_wcc;
};
void *ex_rename3wcc_alloc ();
bool_t xdr_ex_rename3wcc (XDR *, void *);
RPC_STRUCT_DECL (ex_rename3wcc)

template<class T> bool
rpc_traverse (T &t, ex_rename3wcc &obj)
{
  return rpc_traverse (t, obj.fromdir_wcc)
    && rpc_traverse (t, obj.todir_wcc);
}



struct ex_rename3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_rename3wcc> res;
  };

#define rpcunion_tag_ex_rename3res status
#define rpcunion_switch_ex_rename3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  default: \
    action (ex_rename3wcc, res); \
    break; \
  }

  ex_rename3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_rename3res (const ex_rename3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_rename3res () { _base.destroy (); }
  ex_rename3res &operator= (const ex_rename3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_rename3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_rename3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_rename3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_rename3res &obj)
{
  rpcunion_switch_ex_rename3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_rename3res_alloc ();
bool_t xdr_ex_rename3res (XDR *, void *);
RPC_UNION_DECL (ex_rename3res)



struct ex_link3wcc {
  ex_post_op_attr file_attributes;
  ex_wcc_data linkdir_wcc;
};
void *ex_link3wcc_alloc ();
bool_t xdr_ex_link3wcc (XDR *, void *);
RPC_STRUCT_DECL (ex_link3wcc)

template<class T> bool
rpc_traverse (T &t, ex_link3wcc &obj)
{
  return rpc_traverse (t, obj.file_attributes)
    && rpc_traverse (t, obj.linkdir_wcc);
}



struct ex_link3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_link3wcc> res;
  };

#define rpcunion_tag_ex_link3res status
#define rpcunion_switch_ex_link3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  default: \
    action (ex_link3wcc, res); \
    break; \
  }

  ex_link3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_link3res (const ex_link3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_link3res () { _base.destroy (); }
  ex_link3res &operator= (const ex_link3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_link3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_link3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_link3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_link3res &obj)
{
  rpcunion_switch_ex_link3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_link3res_alloc ();
bool_t xdr_ex_link3res (XDR *, void *);
RPC_UNION_DECL (ex_link3res)



struct ex_readdir3resok {
  ex_post_op_attr dir_attributes;
  cookieverf3 cookieverf;
  dirlist3 reply;
};
void *ex_readdir3resok_alloc ();
bool_t xdr_ex_readdir3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_readdir3resok)

template<class T> bool
rpc_traverse (T &t, ex_readdir3resok &obj)
{
  return rpc_traverse (t, obj.dir_attributes)
    && rpc_traverse (t, obj.cookieverf)
    && rpc_traverse (t, obj.reply);
}



struct ex_readdir3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_readdir3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_readdir3res status
#define rpcunion_switch_ex_readdir3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_readdir3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_readdir3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_readdir3res (const ex_readdir3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_readdir3res () { _base.destroy (); }
  ex_readdir3res &operator= (const ex_readdir3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_readdir3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_readdir3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_readdir3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_readdir3res &obj)
{
  rpcunion_switch_ex_readdir3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_readdir3res_alloc ();
bool_t xdr_ex_readdir3res (XDR *, void *);
RPC_UNION_DECL (ex_readdir3res)



struct ex_entryplus3 {
  uint64 fileid;
  filename3 name;
  uint64 cookie;
  ex_post_op_attr name_attributes;
  post_op_fh3 name_handle;
  rpc_ptr<ex_entryplus3> nextentry;
};
void *ex_entryplus3_alloc ();
bool_t xdr_ex_entryplus3 (XDR *, void *);
RPC_STRUCT_DECL (ex_entryplus3)

template<class T> bool
rpc_traverse (T &t, ex_entryplus3 &obj)
{
  return rpc_traverse (t, obj.fileid)
    && rpc_traverse (t, obj.name)
    && rpc_traverse (t, obj.cookie)
    && rpc_traverse (t, obj.name_attributes)
    && rpc_traverse (t, obj.name_handle)
    && rpc_traverse (t, obj.nextentry);
}



struct ex_dirlistplus3 {
  rpc_ptr<ex_entryplus3> entries;
  bool eof;
};
void *ex_dirlistplus3_alloc ();
bool_t xdr_ex_dirlistplus3 (XDR *, void *);
RPC_STRUCT_DECL (ex_dirlistplus3)

template<class T> bool
rpc_traverse (T &t, ex_dirlistplus3 &obj)
{
  return rpc_traverse (t, obj.entries)
    && rpc_traverse (t, obj.eof);
}



struct ex_readdirplus3resok {
  ex_post_op_attr dir_attributes;
  cookieverf3 cookieverf;
  ex_dirlistplus3 reply;
};
void *ex_readdirplus3resok_alloc ();
bool_t xdr_ex_readdirplus3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_readdirplus3resok)

template<class T> bool
rpc_traverse (T &t, ex_readdirplus3resok &obj)
{
  return rpc_traverse (t, obj.dir_attributes)
    && rpc_traverse (t, obj.cookieverf)
    && rpc_traverse (t, obj.reply);
}



struct ex_readdirplus3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_readdirplus3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_readdirplus3res status
#define rpcunion_switch_ex_readdirplus3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_readdirplus3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_readdirplus3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_readdirplus3res (const ex_readdirplus3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_readdirplus3res () { _base.destroy (); }
  ex_readdirplus3res &operator= (const ex_readdirplus3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_readdirplus3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_readdirplus3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_readdirplus3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_readdirplus3res &obj)
{
  rpcunion_switch_ex_readdirplus3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_readdirplus3res_alloc ();
bool_t xdr_ex_readdirplus3res (XDR *, void *);
RPC_UNION_DECL (ex_readdirplus3res)



struct ex_fsstat3resok {
  ex_post_op_attr obj_attributes;
  uint64 tbytes;
  uint64 fbytes;
  uint64 abytes;
  uint64 tfiles;
  uint64 ffiles;
  uint64 afiles;
  uint32 invarsec;
};
void *ex_fsstat3resok_alloc ();
bool_t xdr_ex_fsstat3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_fsstat3resok)

template<class T> bool
rpc_traverse (T &t, ex_fsstat3resok &obj)
{
  return rpc_traverse (t, obj.obj_attributes)
    && rpc_traverse (t, obj.tbytes)
    && rpc_traverse (t, obj.fbytes)
    && rpc_traverse (t, obj.abytes)
    && rpc_traverse (t, obj.tfiles)
    && rpc_traverse (t, obj.ffiles)
    && rpc_traverse (t, obj.afiles)
    && rpc_traverse (t, obj.invarsec);
}



struct ex_fsstat3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_fsstat3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_fsstat3res status
#define rpcunion_switch_ex_fsstat3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_fsstat3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_fsstat3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_fsstat3res (const ex_fsstat3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_fsstat3res () { _base.destroy (); }
  ex_fsstat3res &operator= (const ex_fsstat3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_fsstat3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_fsstat3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_fsstat3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_fsstat3res &obj)
{
  rpcunion_switch_ex_fsstat3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_fsstat3res_alloc ();
bool_t xdr_ex_fsstat3res (XDR *, void *);
RPC_UNION_DECL (ex_fsstat3res)



struct ex_fsinfo3resok {
  ex_post_op_attr obj_attributes;
  uint32 rtmax;
  uint32 rtpref;
  uint32 rtmult;
  uint32 wtmax;
  uint32 wtpref;
  uint32 wtmult;
  uint32 dtpref;
  uint64 maxfilesize;
  nfstime3 time_delta;
  uint32 properties;
};
void *ex_fsinfo3resok_alloc ();
bool_t xdr_ex_fsinfo3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_fsinfo3resok)

template<class T> bool
rpc_traverse (T &t, ex_fsinfo3resok &obj)
{
  return rpc_traverse (t, obj.obj_attributes)
    && rpc_traverse (t, obj.rtmax)
    && rpc_traverse (t, obj.rtpref)
    && rpc_traverse (t, obj.rtmult)
    && rpc_traverse (t, obj.wtmax)
    && rpc_traverse (t, obj.wtpref)
    && rpc_traverse (t, obj.wtmult)
    && rpc_traverse (t, obj.dtpref)
    && rpc_traverse (t, obj.maxfilesize)
    && rpc_traverse (t, obj.time_delta)
    && rpc_traverse (t, obj.properties);
}



struct ex_fsinfo3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_fsinfo3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_fsinfo3res status
#define rpcunion_switch_ex_fsinfo3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_fsinfo3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_fsinfo3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_fsinfo3res (const ex_fsinfo3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_fsinfo3res () { _base.destroy (); }
  ex_fsinfo3res &operator= (const ex_fsinfo3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_fsinfo3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_fsinfo3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_fsinfo3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_fsinfo3res &obj)
{
  rpcunion_switch_ex_fsinfo3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_fsinfo3res_alloc ();
bool_t xdr_ex_fsinfo3res (XDR *, void *);
RPC_UNION_DECL (ex_fsinfo3res)



struct ex_pathconf3resok {
  ex_post_op_attr obj_attributes;
  uint32 linkmax;
  uint32 name_max;
  bool no_trunc;
  bool chown_restricted;
  bool case_insensitive;
  bool case_preserving;
};
void *ex_pathconf3resok_alloc ();
bool_t xdr_ex_pathconf3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_pathconf3resok)

template<class T> bool
rpc_traverse (T &t, ex_pathconf3resok &obj)
{
  return rpc_traverse (t, obj.obj_attributes)
    && rpc_traverse (t, obj.linkmax)
    && rpc_traverse (t, obj.name_max)
    && rpc_traverse (t, obj.no_trunc)
    && rpc_traverse (t, obj.chown_restricted)
    && rpc_traverse (t, obj.case_insensitive)
    && rpc_traverse (t, obj.case_preserving);
}



struct ex_pathconf3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_pathconf3resok> resok;
    union_entry<ex_post_op_attr> resfail;
  };

#define rpcunion_tag_ex_pathconf3res status
#define rpcunion_switch_ex_pathconf3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_pathconf3resok, resok); \
    break; \
  default: \
    action (ex_post_op_attr, resfail); \
    break; \
  }

  ex_pathconf3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_pathconf3res (const ex_pathconf3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_pathconf3res () { _base.destroy (); }
  ex_pathconf3res &operator= (const ex_pathconf3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_pathconf3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_pathconf3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_pathconf3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_pathconf3res &obj)
{
  rpcunion_switch_ex_pathconf3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_pathconf3res_alloc ();
bool_t xdr_ex_pathconf3res (XDR *, void *);
RPC_UNION_DECL (ex_pathconf3res)



struct ex_commit3resok {
  ex_wcc_data file_wcc;
  writeverf3 verf;
};
void *ex_commit3resok_alloc ();
bool_t xdr_ex_commit3resok (XDR *, void *);
RPC_STRUCT_DECL (ex_commit3resok)

template<class T> bool
rpc_traverse (T &t, ex_commit3resok &obj)
{
  return rpc_traverse (t, obj.file_wcc)
    && rpc_traverse (t, obj.verf);
}



struct ex_commit3res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<ex_commit3resok> resok;
    union_entry<ex_wcc_data> resfail;
  };

#define rpcunion_tag_ex_commit3res status
#define rpcunion_switch_ex_commit3res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (ex_commit3resok, resok); \
    break; \
  default: \
    action (ex_wcc_data, resfail); \
    break; \
  }

  ex_commit3res (nfsstat3 _tag = (nfsstat3) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  ex_commit3res (const ex_commit3res &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~ex_commit3res () { _base.destroy (); }
  ex_commit3res &operator= (const ex_commit3res &_s) {
    const_cast<nfsstat3 &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat3 _tag) {
    const_cast<nfsstat3 &> (status) = _tag;
    rpcunion_switch_ex_commit3res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, ex_commit3res &obj)
{
  nfsstat3 tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_ex_commit3res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, ex_commit3res &obj)
{
  rpcunion_switch_ex_commit3res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *ex_commit3res_alloc ();
bool_t xdr_ex_commit3res (XDR *, void *);
RPC_UNION_DECL (ex_commit3res)


#ifndef ex_NFS_PROGRAM
#define ex_NFS_PROGRAM 344444
#endif /* !ex_NFS_PROGRAM */
extern const rpc_program ex_nfs_program_3;
enum { ex_NFS_V3 = 3 };
enum {
  ex_NFSPROC3_NULL = 0,
  ex_NFSPROC3_GETATTR = 1,
  ex_NFSPROC3_SETATTR = 2,
  ex_NFSPROC3_LOOKUP = 3,
  ex_NFSPROC3_ACCESS = 4,
  ex_NFSPROC3_READLINK = 5,
  ex_NFSPROC3_READ = 6,
  ex_NFSPROC3_WRITE = 7,
  ex_NFSPROC3_CREATE = 8,
  ex_NFSPROC3_MKDIR = 9,
  ex_NFSPROC3_SYMLINK = 10,
  ex_NFSPROC3_MKNOD = 11,
  ex_NFSPROC3_REMOVE = 12,
  ex_NFSPROC3_RMDIR = 13,
  ex_NFSPROC3_RENAME = 14,
  ex_NFSPROC3_LINK = 15,
  ex_NFSPROC3_READDIR = 16,
  ex_NFSPROC3_READDIRPLUS = 17,
  ex_NFSPROC3_FSSTAT = 18,
  ex_NFSPROC3_FSINFO = 19,
  ex_NFSPROC3_PATHCONF = 20,
  ex_NFSPROC3_COMMIT = 21,
  ex_NFSPROC3_GETACL = 22,
  ex_NFSPROC3_SETACL = 23,
};
#define ex_NFS_PROGRAM_3_APPLY_NOVOID(macro, void) \
  macro (ex_NFSPROC3_NULL, void, void) \
  macro (ex_NFSPROC3_GETATTR, nfs_fh3, ex_getattr3res) \
  macro (ex_NFSPROC3_SETATTR, setattr3args, ex_wccstat3) \
  macro (ex_NFSPROC3_LOOKUP, diropargs3, ex_lookup3res) \
  macro (ex_NFSPROC3_ACCESS, access3args, ex_access3res) \
  macro (ex_NFSPROC3_READLINK, nfs_fh3, ex_readlink3res) \
  macro (ex_NFSPROC3_READ, read3args, ex_read3res) \
  macro (ex_NFSPROC3_WRITE, write3args, ex_write3res) \
  macro (ex_NFSPROC3_CREATE, create3args, ex_diropres3) \
  macro (ex_NFSPROC3_MKDIR, mkdir3args, ex_diropres3) \
  macro (ex_NFSPROC3_SYMLINK, symlink3args, ex_diropres3) \
  macro (ex_NFSPROC3_MKNOD, mknod3args, ex_diropres3) \
  macro (ex_NFSPROC3_REMOVE, diropargs3, ex_wccstat3) \
  macro (ex_NFSPROC3_RMDIR, diropargs3, ex_wccstat3) \
  macro (ex_NFSPROC3_RENAME, rename3args, ex_rename3res) \
  macro (ex_NFSPROC3_LINK, link3args, ex_link3res) \
  macro (ex_NFSPROC3_READDIR, readdir3args, ex_readdir3res) \
  macro (ex_NFSPROC3_READDIRPLUS, readdirplus3args, ex_readdirplus3res) \
  macro (ex_NFSPROC3_FSSTAT, nfs_fh3, ex_fsstat3res) \
  macro (ex_NFSPROC3_FSINFO, nfs_fh3, ex_fsinfo3res) \
  macro (ex_NFSPROC3_PATHCONF, nfs_fh3, ex_pathconf3res) \
  macro (ex_NFSPROC3_COMMIT, commit3args, ex_commit3res) \
  macro (ex_NFSPROC3_GETACL, diropargs3, ex_read3res) \
  macro (ex_NFSPROC3_SETACL, setaclargs, ex_write3res)
#define ex_NFS_PROGRAM_3_APPLY(macro) \
  ex_NFS_PROGRAM_3_APPLY_NOVOID(macro, void)



struct ex_invalidate3args {
  nfs_fh3 handle;
  ex_post_op_attr attributes;
};
void *ex_invalidate3args_alloc ();
bool_t xdr_ex_invalidate3args (XDR *, void *);
RPC_STRUCT_DECL (ex_invalidate3args)

template<class T> bool
rpc_traverse (T &t, ex_invalidate3args &obj)
{
  return rpc_traverse (t, obj.handle)
    && rpc_traverse (t, obj.attributes);
}


#ifndef ex_NFSCB_PROGRAM
#define ex_NFSCB_PROGRAM 344445
#endif /* !ex_NFSCB_PROGRAM */
extern const rpc_program ex_nfscb_program_3;
enum { ex_NFSCB_V3 = 3 };
enum {
  ex_NFSCBPROC3_NULL = 0,
  ex_NFSCBPROC3_INVALIDATE = 1,
};
#define ex_NFSCB_PROGRAM_3_APPLY_NOVOID(macro, void) \
  macro (ex_NFSCBPROC3_NULL, void, void) \
  macro (ex_NFSCBPROC3_INVALIDATE, ex_invalidate3args, void)
#define ex_NFSCB_PROGRAM_3_APPLY(macro) \
  ex_NFSCB_PROGRAM_3_APPLY_NOVOID(macro, void)

#endif /* !__RPCC_NFS3EXP_PROT_H_INCLUDED__ */
