UTMessageLoop.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_MESSAGE_LOOP_H_
#define _UT_MESSAGE_LOOP_H_


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTThread.h"
#include "UTMutex.h"
#include "UTQuitRequestTask.h"


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
class MessageLoopPlatformInfo_t;


//==================================================================================================
class UT_EXPORT MessageLoop_t
//==================================================================================================
:   public Thread_t,
    private BTreeNode_t< MessageLoop_t, MessageLoop_t* >

{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                            MessageLoop_t(  thread_priority_t priority = eTHREADPRI_normal,
                                            bool support_timeout = false,
                                            int32 timeout_ms = -1 );

    virtual                 ~MessageLoop_t();

    virtual void            SetTimeout(int32 timeout_ms);

    inline int32            Token() const;

    virtual void            Start(int32 stack_size = 0);

    void                    AddTask(Task_t* task);

    void                    RemoveTask(Task_t* task);

    void                    RequestQuit(
                                    const MessageDestination_t<QuitResponseMessage_t>& respond_to );

    void                    RequestQuit();

    virtual void            WaitForThreadToExit();

    virtual void            QuitRequested();

    virtual bool            IsQuitInProgress();

    virtual void            CancelQuit();

    //----------------------------------------------------------------------------------------------
    protected:
    //----------------------------------------------------------------------------------------------
    virtual void            Main();

    virtual void            Timeout();

    virtual void            SetMessageAvailEvent();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------

    // m_message_loops tree management
    inline int              Compare(MessageLoop_t* address) const;
    inline                  operator MessageLoop_t*() const;

    // Message queueing and dispatching
    static void             QueueMessage(takes Message_t* message);

    gives Message_t*        ExtractHeadMessage();

    void                    DispatchMessage(    const Message_t& message,
                                                const AbstractMessageDestination_t& destination );
    void                    DispatchMessage(    takes Message_t* message,
                                                const AbstractMessageDestination_t& destination );
    void                    DispatchMessages();

    static int32            NextMessageLoopToken();

    void                    ResumeQuit();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    int32                                                       m_message_loop_token;

    BTree_t< Task_t, Task_t* >                                  m_tasks;

    bool                                                        m_started;
    bool                                                        m_quit_confirmed;
    bool                                                        m_exit_confirmed;
    QuitRequestTask_t                                           m_quit_request_task;

    // This pair is protected by ms_message_loops_and_queues_mutex
    bool                                                        m_quit;
    OwnedList_t< MessageDestination_t<QuitResponseMessage_t> >  m_quit_response_destinations;
    bool                                                        m_quit_in_progress;

    // Message queue could be a LinkedList_t, but we don't need all that state, and this allows the
    // minimum amount of list mutex protection.
    Message_t* volatile                                         m_head_message;
    Message_t* volatile                                         m_tail_message;
    int                                                         m_dispatching_messages_depth;

    MessageLoopPlatformInfo_t*                                  m_platform_info;
    bool                                                        m_support_timeout;
    int32                                                       m_timeout;

    // The mutex protects the message loops list and, for each message loop, the tail message.
    static Mutex_t                                              ms_message_loops_and_queues_mutex;
    static BTree_t< MessageLoop_t, MessageLoop_t* >             ms_message_loops;

    friend class BTreeNode_t< MessageLoop_t, MessageLoop_t* >;
    friend class BTree_t< MessageLoop_t, MessageLoop_t* >;
    friend class AbstractMessageDestination_t;
    friend class MessageLoopPlatformInfo_t;
    friend class Task_t;
    friend class QuitRequestTask_t;
    friend class App_t;
    friend class AppPlatformInfo_t;
    friend class WindowPlatformInfo_t;
    friend class ViewPlatformInfo_t;
};




//==================================================================================================
//==================================================================================================
//===
//=== Template function implementations: class MessageLoop_t
//===
//==================================================================================================
//==================================================================================================
inline int32
MessageLoop_t::Token() const
{
    return m_message_loop_token;
}


inline int
MessageLoop_t::Compare(MessageLoop_t* address) const
{
    if(this < address)
        return -1;
    else if(this > address)
        return 1;
    else
        return 0;
}


inline
MessageLoop_t::operator MessageLoop_t*() const
{
    return const_cast<MessageLoop_t*>(this);
}


#endif // _UT_MESSAGE_LOOP_H_