cd_prot.c

chord 源码 http://pdos.csail.mit.edu/chord/

  if (prefix)
    sb << prefix << "};\n";
  else
    sb << " }";
  return sb;
}
void
print_cd_lookup_res (const void *_objp, const strbuf *_sbp, int _recdepth,
                     const char *_name, const char *_prefix)
{
  rpc_print (_sbp ? *_sbp : warnx, *static_cast<const cd_lookup_res *> (_objp),
             _recdepth, _name, _prefix);
}
void
dump_cd_lookup_res (const cd_lookup_res *objp)
{
  rpc_print (warnx, *objp);
}

const strbuf &
rpc_print (const strbuf &sb, const cd_getsucclist_arg &obj, int recdepth,
           const char *name, const char *prefix)
{
  if (name) {
    if (prefix)
      sb << prefix;
    sb << "cd_getsucclist_arg " << name << " = ";
  };
  const char *sep;
  str npref;
  if (prefix) {
    npref = strbuf ("%s  ", prefix);
    sep = "";
    sb << "{\n";
  }
  else {
    sep = ", ";
    sb << "{ ";
  }
  rpc_print (sb, obj.vnode, recdepth, "vnode", npref);
  if (prefix)
    sb << prefix << "};\n";
  else
    sb << " }";
  return sb;
}
void
print_cd_getsucclist_arg (const void *_objp, const strbuf *_sbp, int _recdepth,
                          const char *_name, const char *_prefix)
{
  rpc_print (_sbp ? *_sbp : warnx, *static_cast<const cd_getsucclist_arg *> (_objp),
             _recdepth, _name, _prefix);
}
void
dump_cd_getsucclist_arg (const cd_getsucclist_arg *objp)
{
  rpc_print (warnx, *objp);
}

const strbuf &
rpc_print (const strbuf &sb, const cd_getsucclist_res_ok &obj, int recdepth,
           const char *name, const char *prefix)
{
  if (name) {
    if (prefix)
      sb << prefix;
    sb << "cd_getsucclist_res_ok " << name << " = ";
  };
  const char *sep;
  str npref;
  if (prefix) {
    npref = strbuf ("%s  ", prefix);
    sep = "";
    sb << "{\n";
  }
  else {
    sep = ", ";
    sb << "{ ";
  }
  rpc_print (sb, obj.nodes, recdepth, "nodes", npref);
  if (prefix)
    sb << prefix << "};\n";
  else
    sb << " }";
  return sb;
}
void
print_cd_getsucclist_res_ok (const void *_objp, const strbuf *_sbp, int _recdepth,
                             const char *_name, const char *_prefix)
{
  rpc_print (_sbp ? *_sbp : warnx, *static_cast<const cd_getsucclist_res_ok *> (_objp),
             _recdepth, _name, _prefix);
}
void
dump_cd_getsucclist_res_ok (const cd_getsucclist_res_ok *objp)
{
  rpc_print (warnx, *objp);
}

const strbuf &
rpc_print (const strbuf &sb, const cd_getsucclist_res &obj, int recdepth,
           const char *name, const char *prefix)
{
  if (name) {
    if (prefix)
      sb << prefix;
    sb << "cd_getsucclist_res " << name << " = ";
  };
  const char *sep;
  str npref;
  if (prefix) {
    npref = strbuf ("%s  ", prefix);
    sep = "";
    sb << "{\n";
  }
  else {
    sep = ", ";
    sb << "{ ";
  }
  rpc_print (sb, obj.stat, recdepth, "stat", npref);
  switch (obj.stat) {
  case CHORD_OK:
    sb << sep;
    rpc_print (sb, *obj.resok,  recdepth, "resok", npref);
    break;
  default:
    break;
  }
  if (prefix)
    sb << prefix << "};\n";
  else
    sb << " }";
  return sb;
}
void
print_cd_getsucclist_res (const void *_objp, const strbuf *_sbp, int _recdepth,
                          const char *_name, const char *_prefix)
{
  rpc_print (_sbp ? *_sbp : warnx, *static_cast<const cd_getsucclist_res *> (_objp),
             _recdepth, _name, _prefix);
}
void
dump_cd_getsucclist_res (const cd_getsucclist_res *objp)
{
  rpc_print (warnx, *objp);
}

#endif /* MAINTAINER*/
void *
cd_vnode_alloc ()
{
  return New cd_vnode;
}
bool_t
xdr_cd_vnode (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_vnode *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_vnode *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
chord_node_wire_plus_id_alloc ()
{
  return New chord_node_wire_plus_id;
}
bool_t
xdr_chord_node_wire_plus_id (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<chord_node_wire_plus_id *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<chord_node_wire_plus_id *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_routing_mode_alloc ()
{
  return New cd_routing_mode;
}
bool_t
xdr_cd_routing_mode (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_routing_mode *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_routing_mode *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_newchord_arg_alloc ()
{
  return New cd_newchord_arg;
}
bool_t
xdr_cd_newchord_arg (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_newchord_arg *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_newchord_arg *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_newchord_res_ok_alloc ()
{
  return New cd_newchord_res_ok;
}
bool_t
xdr_cd_newchord_res_ok (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_newchord_res_ok *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_newchord_res_ok *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_newchord_res_alloc ()
{
  return New cd_newchord_res;
}
bool_t
xdr_cd_newchord_res (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_newchord_res *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_newchord_res *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_unnewchord_res_alloc ()
{
  return New cd_unnewchord_res;
}
bool_t
xdr_cd_unnewchord_res (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_unnewchord_res *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_unnewchord_res *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_lookup_arg_alloc ()
{
  return New cd_lookup_arg;
}
bool_t
xdr_cd_lookup_arg (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_lookup_arg *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_lookup_arg *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_lookup_res_ok_alloc ()
{
  return New cd_lookup_res_ok;
}
bool_t
xdr_cd_lookup_res_ok (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_lookup_res_ok *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_lookup_res_ok *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_lookup_res_alloc ()
{
  return New cd_lookup_res;
}
bool_t
xdr_cd_lookup_res (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_lookup_res *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_lookup_res *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_getsucclist_arg_alloc ()
{
  return New cd_getsucclist_arg;
}
bool_t
xdr_cd_getsucclist_arg (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_getsucclist_arg *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_getsucclist_arg *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_getsucclist_res_ok_alloc ()
{
  return New cd_getsucclist_res_ok;
}
bool_t
xdr_cd_getsucclist_res_ok (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_getsucclist_res_ok *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_getsucclist_res_ok *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

void *
cd_getsucclist_res_alloc ()
{
  return New cd_getsucclist_res;
}
bool_t
xdr_cd_getsucclist_res (XDR *xdrs, void *objp)
{
  switch (xdrs->x_op) {
  case XDR_ENCODE:
  case XDR_DECODE:
    return rpc_traverse (xdrs, *static_cast<cd_getsucclist_res *> (objp));
  case XDR_FREE:
    rpc_destruct (static_cast<cd_getsucclist_res *> (objp));
    return true;
  default:
    panic ("invalid xdr operation %d\n", xdrs->x_op);
  }
}

static const rpcgen_table cd_program_1_tbl[] = {
  CD_PROGRAM_1_APPLY (XDRTBL_DECL)
};
const rpc_program cd_program_1 = {
  CD_PROGRAM, CD_VERSION, cd_program_1_tbl,
  sizeof (cd_program_1_tbl) / sizeof (cd_program_1_tbl[0]),
  "cd_program_1"
};