UTTimer.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// 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, version 2.0 of the
// License.
//
// 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., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_TIMER_H_
#define _UT_TIMER_H_


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTTask.h"
#include "UTMessage.h"


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
class TimerExpiredMessage_t;
class TimerManager_t;
class TimersPlatformInfo_t;


//==================================================================================================
class UT_EXPORT Timer_t
//==================================================================================================
:   private BTreeNode_t< Timer_t, ustime_t >
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline  Timer_t(bool accept_jitter = false);

    inline  ~Timer_t();

    void    StartOneShot(   ustime_t expires_at,
                            const MessageDestination_t<TimerExpiredMessage_t>& dest,
                            TimerManager_t* manager );

    void    StartPeriodic(  uint32 period_ms,
                            const MessageDestination_t<TimerExpiredMessage_t>& dest,
                            TimerManager_t* manager );

    void    Cancel();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    inline int                                  Compare(ustime_t other) const;
    inline                                      operator ustime_t() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    TimerManager_t*                             m_owner;
    bool                                        m_periodic;
    bool                                        m_accept_jitter;
    ustime_t                                    m_next_expire_at;
    uint32                                      m_period_ms;
    MessageDestination_t<TimerExpiredMessage_t> m_dest;

    friend class BTree_t< Timer_t, ustime_t >;
    friend class BTreeNode_t< Timer_t, ustime_t >;
    friend class TimerManager_t;
};


//==================================================================================================
class UT_EXPORT TimerManager_t
//==================================================================================================
: public Task_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                                    TimerManager_t();

                                    ~TimerManager_t();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void                            Add(Timer_t* timer);
    void                            Remove(Timer_t* timer);
    Timer_t*                        DispatchExpiredTimers();
                                        // Returns a pointer to the next timer to expire

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    BTree_t< Timer_t, ustime_t >    m_timers;
    TimersPlatformInfo_t*           m_platform_info;
    bool                            m_reset_timer_msg_pending;
    bool                            m_quitting;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void TimerExpiredReceived(const TimerExpiredMessage_t* message);
    MessageReceiver_t< TimerManager_t, TimerExpiredMessage_t >  m_TimerExpiredReceiver;

    friend class Timer_t;
    friend class TimersPlatformInfo_t;
};


//==================================================================================================
class UT_EXPORT TimerExpiredMessage_t
//==================================================================================================
: public Message_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline Timer_t* Timer() const;

    inline ustime_t DispatchTime() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    inline          TimerExpiredMessage_t();
    inline          TimerExpiredMessage_t( Timer_t* timer, ustime_t dispatch_time );

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    Timer_t*        m_timer;
    ustime_t        m_dispatch_time;

    friend class TimerManager_t;
    friend class TimersPlatformInfo_t;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class Timer_t
//===
//==================================================================================================
//==================================================================================================
inline
Timer_t::Timer_t(bool accept_jitter)
{
    m_owner = NULL;
    m_accept_jitter = accept_jitter;
}


inline
Timer_t::~Timer_t()
{
    Cancel();
    assert(m_owner == NULL);
}


inline int
Timer_t::Compare(ustime_t other) const
{
    if(m_next_expire_at - other < 0)
        return -1;
    if(m_next_expire_at - other > 0)
        return 1;
    return 0;
}


inline
Timer_t::operator ustime_t() const
{
    return m_next_expire_at;
}




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class TimerExpiredMessage_t
//===
//==================================================================================================
//==================================================================================================
inline
TimerExpiredMessage_t::TimerExpiredMessage_t()
{
    // Nothing to do
}


inline Timer_t*
TimerExpiredMessage_t::Timer() const
{
    return m_timer;
}


inline
TimerExpiredMessage_t::TimerExpiredMessage_t( Timer_t* timer, ustime_t dispatch_time )
{
    m_timer = timer;
    m_dispatch_time = dispatch_time;
}


inline ustime_t
TimerExpiredMessage_t::DispatchTime() const
{
    return m_dispatch_time;
}


#endif // _UT_TIMER_H_