timer.cc,v

这是P2P流媒体方案－NICE的实现源码

head	1.1;
access;
symbols;
locks; strict;
comment	@// @;


1.1
date	2002.07.02.19.30.35;	author rbraud;	state Exp;
branches;
next	;


desc
@@


1.1
log
@Initial revision
@
text
@/*
 * File: timer.cc
 * Author: Suman Banerjee <suman@@cs.umd.edu>
 * Date: 15th February, 2002
 * Terms: GPL
 *
 * NICE Application Layer Multicast
 */

#include <stdio.h>
#include <assert.h>
//#include "scheduler.h"
#include "timer.h"
#include "o_timeout.h"
#include "agent.h"

bool glob_handling_expired_timers;
LinkedList<Timer *, int> expired_timer_list; /* All expired timers */
LinkedList<TimerInfo *, int> valid_timer_list; /* All the timers that are valid,
				         should check before handler called */

bool handle_timer_now = false;

int Timer::timer_id_gen = 0;
int Timer::timer_instance_gen = 0;

void wrapper_handler(int a) {

    int call_unmask_timer = mask_timer();
    TimerInfo *ti = (TimerInfo *)a;
    Timer * t = ti->t; 
    //if(verify_and_remove_timer_instance(ti->instance) == true)
    t->Handler(false);
    if (call_unmask_timer == CALL_UNMASK_TIMER)
      unmask_timer();
    return;
}


Timer::Timer(void) {

  id = timer_id_gen; 
  timer_id_gen ++; 
  instance = -1;
  is_set = false; 
};
 
Timer::~Timer (void) {

  CancelTimer();
}

void Timer::SetTimer (double rel_time) {

  int call_unmask_timer = mask_timer();
  assert (is_set == false);
  //  EventInfo *e = new EventInfo(EVENT_TIMER,(void*)this,NULL);
  //  pos = Scheduler::AddRelativeEvent(rel_time,e);
  instance = timer_instance_gen ++;
  TimerInfo * ti = add_to_timer_instance_list(this);

  handle = startTimer((int) rel_time, wrapper_handler, (int) ti, 0);
  is_set = true;
  if (call_unmask_timer == CALL_UNMASK_TIMER)
    unmask_timer();
  return;
}

void Timer::CancelTimer (void) {

   int call_unmask_timer = mask_timer();

  verify_and_remove_timer_instance(instance);
  instance = -1;
  if (is_set == true) {
    /*
    EventInfo *e = Scheduler::DeleteEvent(pos);
    assert (e->et == EVENT_TIMER);
    delete e;
  }
    */
    is_set = false;
    cancelTimer(handle);
  }
  if(glob_handling_expired_timers == false) {
    void *pos = expired_timer_list.GetHeadPosition();
    while (pos != NULL) {
      Timer *t = expired_timer_list.GetAt(pos);
      void * old_pos = pos;
      expired_timer_list.GetNext(pos);
      if (t == this)
        expired_timer_list.RemoveAt(old_pos);
    }
  }

  if(call_unmask_timer == CALL_UNMASK_TIMER)
    unmask_timer();

  return;
}

void Timer::Handler (bool from_handle_expired_timers) {

  is_set = false;
  if ( (from_handle_expired_timers == true) || (handle_timer_now == true) ) {
    if(verify_and_remove_timer_instance(instance) == true) {
      instance = -1;
      EventHandler(from_handle_expired_timers);
    }
    fflush(stdout);
  }
  else
   add_expired_timer(this);
  return;
}

/* SHOULD BE A VIRTUAL FUNCTION : DONT DEFINE IT
void Timer::EventHandler (void) {

  printf ("this is a problem\n");
  return;
}
*/

TimerInfo * add_to_timer_instance_list (Timer *t) {
  
  TimerInfo *ti = new TimerInfo(t,t->get_instance());

  valid_timer_list.Add(ti,ti->instance);
  return ti;
}

bool verify_and_remove_timer_instance (int a) {

  TimerInfo *ti = NULL;
  void * pos = valid_timer_list.GetHeadPosition();
  while (pos != NULL) {
    //ti = (TimerInfo *)(valid_timer_list.GetAt(pos));
    ti = valid_timer_list.GetAt(pos);
    if (ti->instance == a) {
      valid_timer_list.RemoveAt(pos);
      delete ti;
      return true;
    }
    valid_timer_list.GetNext(pos);
  }
  return false;
}

void handle_expired_timers(void) {

  int call_unmask_timer;

  call_unmask_timer = mask_timer();
  glob_handling_expired_timers = true;
  
  for (void *pos = expired_timer_list.GetHeadPosition();
       pos != NULL;
       pos = expired_timer_list.GetHeadPosition() ) {
    Timer *t = expired_timer_list.GetAt(pos);
    expired_timer_list.RemoveAt(pos);
    //if (verify_and_remove_timer_instance(t->get_instance()) == true)
    t->Handler(true);
  }

  //expired_timer_list.RemoveAll();
  glob_handling_expired_timers = false;
  if(call_unmask_timer == CALL_UNMASK_TIMER)
    unmask_timer();

  fflush(stdout);
  return;
}

void add_expired_timer(Timer * t) {

  expired_timer_list.Add(t, t->get_id());
  return;
}

void enable_handle_timers (void) {

  handle_timer_now = true;
}

void disable_handle_timers (void) {

  handle_timer_now = false;
}
@