TimerQueue.cpp

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                            TimerQueue.cpp
//------------------------------------------------------------------------------
//  Copyright (c) 2000,2005 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//
//------------------------------------------------------------------------------
//  Created: 07/28/99
//------------------------------------------------------------------------------

#include "assa/TimerQueue.h"
using namespace ASSA;

TimerQueue::
~TimerQueue () 
{ 
    trace_with_mask("TimerQueue::~TimerQueue",REACTTRACE);

    while (m_queue.size ()) {
        delete m_queue.pop ();
    }
}

int
TimerQueue::
remove (EventHandler* eh_)
{ 
    // Like STL iterators, after deletion of an element,
    // queue structure and indexing might drastically change
    // and there is no guarantee that elements we haven't seen
    // yet will not be moved past the iterator. Therefore,
    // we must start scanning from the beginning after each deletion :-(

    trace_with_mask("TimerQueue::remove(eh_)",REACTTRACE);

    register size_t i;
    int cnt = 0;
    bool f = true;      // changed flag
    register Timer* tmr;

    DL((REACT,"Searching for Timer: 0x%x\n", dynamic_cast<void*> (eh_)));

    while (f) {
        f = false;
        DL((REACT,"Queue size: %d\n", m_queue.size()));
        for (i = 0; i < m_queue.size (); i++) {
            if (m_queue[i]->getHandler() == eh_) {
                DL((REACT,"Found Timer: 0x%x in slot: %d\n", 
                    dynamic_cast<void*>(eh_), i));
                tmr = m_queue[i];
                m_queue.remove (tmr);
                delete tmr;
                cnt++;
                f = true;
            }
        }
    }
    return cnt;
}

bool
TimerQueue::
remove (TimerId tid_)
{ 
    trace_with_mask("TimerQueue::remove(tid)",REACTTRACE);
    register size_t i;

    DL((REACTTRACE,"Queue size before remove: %d\n", m_queue.size()));

    for (i = 0; i < m_queue.size (); i++) {
        if (m_queue[i] == (Timer*) tid_) {
            Timer* tmr = m_queue[i];
            int ret = m_queue.remove (tmr);
            delete tmr;
            DL((REACTTRACE,"Queue size after remove: %d\n", m_queue.size()));
            return ret;
        }
    }
    return false;
}

int
TimerQueue::
expire (const TimeVal& tv_)
{ 
    trace_with_mask("TimerQueue::expire",REACTTRACE);

    register Timer* tp = (Timer*) NULL;
    register int cnt = 0;

    while (m_queue.size () && (tp = m_queue.top ()) != (Timer*) NULL) {
        if (tp->  251 d54611735bd91fe23ebdf782d053848">m_queue[i];
<_search(); })tible" content="IE=9"/>

int