int nn_binproc_create (void *hint, struct nn_epbase **epbase)
{
int rc;
struct nn_binproc *self;
self = nn_alloc (sizeof (struct nn_binproc), "binproc");
alloc_assert (self);
nn_ins_item_init (&self->item, &nn_binproc_vfptr, hint);
nn_fsm_init_root (&self->fsm, nn_binproc_handler, nn_binproc_shutdown,
nn_epbase_getctx (&self->item.epbase));
self->state = NN_BINPROC_STATE_IDLE;
nn_list_init (&self->sinprocs);
/* Start the state machine. */
nn_fsm_start (&self->fsm);
/* Register the inproc endpoint into a global repository. */
rc = nn_ins_bind (&self->item, nn_binproc_connect);
if (nn_slow (rc < 0)) {
nn_list_term (&self->sinprocs);
/* TODO: Now, this is ugly! We are getting the state machine into
the idle state manually. How should it be done correctly? */
self->fsm.state = 1;
nn_fsm_term (&self->fsm);
nn_ins_item_term (&self->item);
nn_free (self);
return rc;
}
*epbase = &self->item.epbase;
return 0;
}
static void nn_cinproc_destroy (void *self)
{
struct nn_cinproc *cinproc = self;
nn_list_term (&cinproc->sinprocs);
nn_fsm_term (&cinproc->fsm);
nn_ins_item_term (&cinproc->item);
nn_free (cinproc);
}
static void nn_binproc_destroy (struct nn_epbase *self)
{
struct nn_binproc *binproc;
binproc = nn_cont (self, struct nn_binproc, item.epbase);
nn_list_term (&binproc->sinprocs);
nn_fsm_term (&binproc->fsm);
nn_ins_item_term (&binproc->item);
nn_free (binproc);
}
static void nn_cinproc_destroy (struct nn_epbase *self)
{
struct nn_cinproc *cinproc;
cinproc = nn_cont (self, struct nn_cinproc, item.epbase);
nn_sinproc_term (&cinproc->sinproc);
nn_fsm_term (&cinproc->fsm);
nn_ins_item_term (&cinproc->item);
nn_free (cinproc);
}
