timer_destroy.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_destroy.c,v 1.2 2005/09/15 18:14:11 klmitch Exp $
*/
#include "engines_int.h"

RCSTAG("@(#)$Id: timer_destroy.c,v 1.2 2005/09/15 18:14:11 klmitch Exp $");

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

  ev_trace();

  ev_assert(ctx->ec_timtree.tt_root);

  /* Check to see if this is the last timer in the tree */
  if (!ctx->ec_timtree.tt_root->ti_node.tn_left) {
    ev_assert(ctx->ec_timtree.tt_root == tim);

    /* empty the tree */
    ctx->ec_timtree.tt_root = 0;
    ctx->ec_timtree.tt_insert = 0;

    /* Clear the node pointers */
    tt_node_init(tim, 0, 0);

    ev_return(0); /* short-circuit the rest of the checks */
  }

  ev_assert(ctx->ec_timtree.tt_insert);

  /* Find the end node of the tree... */
  if (ctx->ec_timtree.tt_insert->ti_node.tn_right) {
    /* cursor points to a full node; grab the right child... */
    end = ctx->ec_timtree.tt_insert->ti_node.tn_right;
    ctx->ec_timtree.tt_insert->ti_node.tn_right = 0;
  } else { /* cursor points to a half-full node... */
    end = ctx->ec_timtree.tt_insert->ti_node.tn_left; /* take left child */
    ctx->ec_timtree.tt_insert->ti_node.tn_left = 0;

    /* Move the cursor back to point at a full node if there is one... */
    ctx->ec_timtree.tt_insert =
      (ctx->ec_timtree.tt_insert->ti_node.tn_prev == ctx->ec_timtree.tt_root &&
       !ctx->ec_timtree.tt_root->ti_node.tn_left) ?
      0 : ctx->ec_timtree.tt_insert->ti_node.tn_prev;
  }

  ev_assert(end->ti_node.tn_prev);
  ev_assert(!end->ti_node.tn_next);

  /* unlink end node from the linked list threading through the tree */
  end->ti_node.tn_prev->ti_node.tn_next = 0;

  if (end != tim) { /* substitute end node for timer */
    int tmp;

    end->ti_node = tim->ti_node; /* move node pointers over */
    tt_node_fix(end); /* fix most of the referring pointers */

    if (!end->ti_node.tn_parent) /* no parent means this is the root... */
      ctx->ec_timtree.tt_root = end;
    else if (end->ti_node.tn_parent->ti_node.tn_left == tim)
      /* parent pointed from the left; update that pointer */
      end->ti_node.tn_parent->ti_node.tn_left = end;
    else /* parent pointed from the right; update that pointer */
      end->ti_node.tn_parent->ti_node.tn_right = end;

    if (ctx->ec_timtree.tt_insert == tim) /* fix insertion cursor */
      ctx->ec_timtree.tt_insert = end;

    if ((tmp = tv_comp(&end->ti_expire, &tim->ti_expire)) < 0)
      /* new value is earlier than the old timer */
      err = _timer_heapify_down(ctx, end);
    else if (tmp > 0) /* new value is later than the old timer */
      err = _timer_heapify_up(ctx, end);
  }

  tt_node_init(tim, 0, 0); /* clear the node */

  ev_return(err);
}

ev_err_t
timer_destroy(ev_ctx_t *ctx, ev_tim_t *tim)
{
  ev_engine_t *eng;
  ev_err_t err, err2;

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

  /* sanity-check the arguments... */
  if (!ec_verify(ctx) || !ti_verify(tim) || eg_context(tim) != ctx)
    ev_return(EINVAL);

  if (eg_flags(tim) & EV_GEN_DELETED) /* skip already deleted timers */
    ev_return(0);

  err = _timer_untree(ctx, tim); /* remove timer from timer tree... */

  /* Walk through all the timer engines (last to first)... */
  for (eng = ctx->ec_timer.el_last; eng;
       eng = eng->eng_timer.eti_active.el_prev)
    if ((err2 = eng_tim_rem(ctx, eng, tim)) && !err) /* remove the timer... */
      err = err2; /* don't interrupt removal, but remember error code */

  eg_flags_set(tim, EV_GEN_DELETED); /* mark it as deleted */

  /* decrement the reference count */
  eg_ref_dec(ctx, tim);

  ev_return(err);
}

---