UTIdleTask.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_IDLE_TASK_H_
#define _UT_IDLE_TASK_H_


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTMessageLoop.h"
#include "UTMutex.h"
#include "UTIdleAddRemoveTask.h"


//==================================================================================================
class UT_EXPORT IdleTask_t
//==================================================================================================
:   public Task_t,
    private BTreeNode_t< IdleTask_t, roughtime_t >
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline          IdleTask_t(int32 poll_interval_seconds);

    inline void     SetPollInterval(int32 poll_interval_seconds);

    virtual void    PerformIdleWork() = 0;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    inline int      Compare(roughtime_t poll_time) const;
    inline          operator roughtime_t() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    int32           m_poll_interval_ms;
    roughtime_t     m_next_poll_time;

    friend class BTreeNode_t< IdleTask_t, roughtime_t >;
    friend class BTree_t< IdleTask_t, roughtime_t >;
    friend class IdleMessageLoop_t;
};


// \cond DOXYGEN_DOCUMENT_NEVER

#if SYSTEM_TIME_MAX_INTERVAL_SECONDS

//==================================================================================================
class SystemTimeProtectTask_t
//==================================================================================================
: public IdleTask_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                    SystemTimeProtectTask_t();
    virtual void    PerformIdleWork();
};

#endif // SYSTEM_TIME_MAX_INTERVAL_SECONDS

// \endcond


//==================================================================================================
class UT_EXPORT IdleMessageLoop_t
//==================================================================================================
: public MessageLoop_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                    IdleMessageLoop_t();

                    ~IdleMessageLoop_t();

    void            AddIdleTask(IdleTask_t* task);

    void            RemoveIdleTask(IdleTask_t* task);

    //----------------------------------------------------------------------------------------------
    protected:
    //----------------------------------------------------------------------------------------------
    // \cond DOXYGEN_DOCUMENT_NEVER
    virtual void    Timeout();
    // \endcond

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void            StartIdleThread();
    void            SetPollInterval( IdleTask_t* task, int32 poll_interval_seconds );
    #if SYSTEM_TIME_MAX_INTERVAL_SECONDS
    void            StartSystemTimeProtection();
    #endif

    void            ResetTimeout(roughtime_t now);

    void            Shutdown();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    volatile bool                                   m_running;
    volatile bool                                   m_system_time_protected;

    BTree_t< IdleTask_t, roughtime_t >              m_idle_tasks;
    IdleAddRemoveTask_t                             m_add_remove_task;
    MessageDestination_t<IdleAddRemoveMessage_t>    m_add_destination;
    MessageDestination_t<IdleAddRemoveMessage_t>    m_remove_destination;

    #if SYSTEM_TIME_MAX_INTERVAL_SECONDS
    SystemTimeProtectTask_t                         m_system_time_protect_task;
    #endif

    Mutex_t                                         m_start_or_remove_mutex;
    Event_t                                         m_remove_complete_event;

    static IdleMessageLoop_t*                       ms_singleton;

    friend class IdleTask_t;
    friend class SystemTimeManager_t;
    friend class Thread_t;
    friend class IdleAddRemoveTask_t;
};


extern UT_EXPORT IdleMessageLoop_t g_idle_message_loop;




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations
//===
//==================================================================================================
//==================================================================================================
inline
IdleTask_t::IdleTask_t(int32 poll_interval_seconds)
{
    assert(poll_interval_seconds >= 2 && poll_interval_seconds <= 1073741);
    m_poll_interval_ms = poll_interval_seconds * 1000;
}


inline void
IdleTask_t::SetPollInterval(int32 poll_interval_seconds)
{
    assert(poll_interval_seconds >= 2 && poll_interval_seconds <= 1073741);
    if( !MessageLoop() )
    {
        m_poll_interval_ms = poll_interval_seconds * 1000;
        return;
    }
    IdleMessageLoop_t::ms_singleton->SetPollInterval( this, poll_interval_seconds );
}


inline int
IdleTask_t::Compare(roughtime_t poll_time) const
{
    if(m_next_poll_time > poll_time)
        return 1;
    else if(m_next_poll_time < poll_time)
        return -1;
    return 0;
}


inline
IdleTask_t::operator roughtime_t() const
{
    return m_next_poll_time;
}


#endif // _UT_IDLE_TASK_H_