timer_create.c

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: timer_create.c,v 1.3 2005/10/25 01:46:17 klmitch Exp $
*/
#include "engines_int.h"

RCSTAG("@(#)$Id: timer_create.c,v 1.3 2005/10/25 01:46:17 klmitch Exp $");

ev_err_t
_timer_insert(ev_ctx_t *ctx, ev_tim_t *tim)
{
  ev_err_t err = 0;

  ev_trace();

  /* Let's add the timer to the tree... */
  if (!ctx->ec_timtree.tt_root) { /* tree is empty... */
    ctx->ec_timtree.tt_root = tim; /* put timer at root... */

    tt_node_init(tim, 0, 0); /* initialize timer node */
  } else if (!ctx->ec_timtree.tt_insert) { /* no insertion cursor? */
    ev_assert(ctx->ec_timtree.tt_root);

    ctx->ec_timtree.tt_root->ti_node.tn_left = tim; /* put on the left */
    ctx->ec_timtree.tt_insert = ctx->ec_timtree.tt_root; /* insert at root */

    tt_node_init(tim, ctx->ec_timtree.tt_root, ctx->ec_timtree.tt_root);
  } else if (!ctx->ec_timtree.tt_insert->ti_node.tn_right) {
    ev_assert(ctx->ec_timtree.tt_insert->ti_node.tn_left);

    /* insertion cursor points at half-full node, so insert there */
    ctx->ec_timtree.tt_insert->ti_node.tn_right = tim;

    tt_node_init(tim, ctx->ec_timtree.tt_insert, /* initialize timer node */
                 ctx->ec_timtree.tt_insert->ti_node.tn_left);
  } else { /* insertion cursor points at a full node... */
    ev_assert(ctx->ec_timtree.tt_insert->ti_node.tn_left);
    ev_assert(ctx->ec_timtree.tt_insert->ti_node.tn_next);

    /* add timer to next timer after insertion cursor */
    ctx->ec_timtree.tt_insert->ti_node.tn_next->ti_node.tn_left = tim;

    /* initialize the timer node */
    tt_node_init(tim, ctx->ec_timtree.tt_insert->ti_node.tn_next,
                 ctx->ec_timtree.tt_insert->ti_node.tn_right);

    /* move the insertion cursor */
    ctx->ec_timtree.tt_insert = ctx->ec_timtree.tt_insert->ti_node.tn_next;
  }

  if ((err = _timer_heapify_up(ctx, tim))) /* heapify the thing */
    timer_destroy(ctx, tim); /* failed, destroy the timer... */

  ev_return(err);
}

ev_err_t
timer_create(ev_ctx_t *ctx, ev_timtype_t type, struct timeval *value,
             ev_call_t call, void *data, ev_tim_t **tim_p)
{
  ev_engine_t *eng;
  ev_err_t err = 0;
  ev_tim_t *tim;

  ev_init(); /* make sure library is initialized... */

  /* sanity-check the arguments... */
  if (!ec_verify(ctx) || (type != TT_ABSOLUTE && type != TT_RELATIVE &&
                          type != TT_PERIODIC) || !value)
    ev_return(EINVAL);

  /* Let's allocate a generator... */
  if ((err = event_gen_alloc(ctx, EGT_TIMER, &tim)))
    ev_return(err);

  /* Set callback information */
  eg_callback_set(tim, call);
  eg_calldata_set(tim, data);

  /* Now initialize the timer fields... */
  tim->ti_type = type;
  tim->ti_value = *value;
  ti_expire_comp(tim); /* compute expiration time... */

  /* Walk through all the timer engines... */
  for (eng = ctx->ec_timer.el_first; eng;
       eng = eng->eng_timer.eti_active.el_next)
    if ((err = eng_tim_add(ctx, eng, tim))) { /* add to engine... */
      /* oops!  Error occurred.  Walk engines backwards and remove timer */
      for (; eng; eng = eng->eng_timer.eti_active.el_prev)
        eng_tim_rem(ctx, eng, tim);

      event_gen_release(ctx, (ev_genhdr_t *)tim); /* release timer memory */

      ev_return(err); /* return the error */
    }

  if ((err = _timer_insert(ctx, tim))) /* insert into the tree */
    ev_return(err);

  eg_ref_inc(ctx, tim); /* increment the reference count */

  if (tim_p) /* did caller want the timer? */
    *tim_p = tim; /* then return it */

  ev_return(0);
}

---