---

Timer.h

Go to the documentation of this file.

/*
 * Timer.h
 *
 * Copyright 2003, MobileSpear Inc. (www.mobilespear.com). All rights reserved.
 * Copyright 2003, David Resnick. All rights reserved.
 *
 * See the file doc\license.txt for the terms of usage and distribution.
 */

#ifndef _BOGOTEL_TIMER_H
#define _BOGOTEL_TIMER_H

#include <string>
#include <list>
#include <set>
#include <vector>

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>

#include <gclib.h>

#include <bogotel/BgtErrors.h>

#include <bogotel/STLhelp.h>
#include <bogotel/timertarget.h>

namespace bogotel {

    class CDevBase;

    class timer_info {

    public:

        CTimerTarget* m_pTarget; // Device requesting timer.
        int m_count;          // Number of periodic timers before timer request expires.
        int m_iTimerType;
        // ID used to detect if the state of the target has changed since 
        // the timer was set
        int m_iTargetStateId; 

        long m_lTargetId;

        /*
         *  Default constructor
         */
        timer_info(int count, CTimerTarget* pTarget, int timerType = 0, int targetStateId = 0);

        /*
         *  Overload the GreaterThan, LessThan, and EqualTo Operators
         *  so this structure can be sorted in an STL list.
         */
        bool operator < (const timer_info & rhs) {

             return (this->m_count < rhs.m_count);
        }    

        bool operator > (const timer_info & rhs) {

            return (this->m_count > rhs.m_count);
        }

        bool operator == (const timer_info & rhs) {
            if (this->m_iTimerType != rhs.m_iTimerType)
                return false;
            if (this->m_count != rhs.m_count)
                return false;
            if (this->m_lTargetId != rhs.m_lTargetId)
                return false;
            if (this->m_iTargetStateId != rhs.m_iTargetStateId)
                return false;
            if (this->m_pTarget != rhs.m_pTarget)
                return false;

            return true;
        }

        timer_info* operator = (timer_info & rhs) {

            this->m_pTarget        = rhs.m_pTarget;
            this->m_count          = rhs.m_count;
            this->m_iTimerType     = rhs.m_iTimerType;
            this->m_iTargetStateId = rhs.m_iTargetStateId;
            this->m_lTargetId      = rhs.m_lTargetId;

            return(this);
        }

        std::string toString();
    };

    typedef std::list<timer_info*>     LST_TIMER;
    typedef std::vector<CTimerTarget*> VEC_TIMERTARGET;
    typedef std::set<long>             SET_LONG;

    // This class implements a delayed queue.
    // Devices (both signal and voice) use it to be informed of
    // termination of processes they have started, such as
    // timeout for making a call or playback of a WAV finishing.
    // Has a worker thread.
    class CTimer  
    {

    public:

        CTimer(int period = 100);
        virtual ~CTimer();

        void run();

        void add(long lDelay, CTimerTarget *pTarget, int timerType = 0, int stateId = 0);
        
        static void do_thread(void* param);

        int registerTarget(CTimerTarget *pTarget);
        void requestTargetDeletion(CTimerTarget *pTarget);

    private:

        void checkForExpirations();
        void handleDefunctTargets();
        bool targetIsActive(long lTargetId);

        boost::thread* m_pThrd;
        boost::mutex m_mtxTimerInfoList; 
        boost::mutex m_mtxActiveTimerSet; 
        boost::mutex m_mtxDefunctVec; 
        boost::mutex m_mtxStop;
        boost::condition m_condStop;
        bool m_bStop;

        int m_period;            // Period Timer Length.

        // List of Devices using this timer with time in ticks as key
        LST_TIMER       m_lstTimer;  
        // active timer targets
        SET_LONG        m_setActive; 
        // timer targets to be removed from the active set
        VEC_TIMERTARGET m_vecDefunct;
    };

}

#endif // !defined(_BOGOTEL_TIMER_H)

---