UTMessageDestination.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_DESTINATION_H_
#define _UT_MESSAGE_DESTINATION_H_


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTMessageReceiver.h"
#include "UTLists.h"


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
class MessageLoop_t;


// \cond DOXYGEN_DOCUMENT_NEVER
//==================================================================================================
class UT_EXPORT AbstractMessageDestination_t
//==================================================================================================
: public LinkedListNode_t<AbstractMessageDestination_t>
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline                      AbstractMessageDestination_t();
                                AbstractMessageDestination_t(
                                                            MessageLoop_t* message_loop,
                                                            Task_t* task,
                                                            AbstractMessageReceiver_t* receiver );
    inline void                 Set(const AbstractMessageDestination_t& copy);
    inline const AbstractMessageDestination_t&
                                operator=(const AbstractMessageDestination_t& copy);
    inline bool                 IsValid() const;
    inline void                 Invalidate();
    inline MessageLoop_t*       MessageLoop() const;

    void                        SendMessage(    const Message_t& message,
                                                const MessageLoop_t* sent_from_context ) const;
    void                        SendMessageAsync(takes Message_t* message) const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    MessageLoop_t*              m_message_loop;
    int32                       m_message_loop_token;
    Task_t*                     m_task;
    int32                       m_task_token;
    AbstractMessageReceiver_t*  m_receiver;

    friend class Message_t;
    friend class MessageLoop_t;
};
// \endcond



//==================================================================================================
template <class MESSAGE_TYPE>
class MessageDestination_t
//==================================================================================================
: public AbstractMessageDestination_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline                  MessageDestination_t();

    inline                  MessageDestination_t(   MessageLoop_t* message_loop,
                                                    Task_t* task,
                                                    MessageTypeReceiver_t<MESSAGE_TYPE>* receiver );

    inline const            MessageDestination_t<MESSAGE_TYPE>&
                                        operator =(const MessageDestination_t<MESSAGE_TYPE>& copy);

    inline bool             IsValid() const;

    inline void             Invalidate();

    inline MessageLoop_t*   MessageLoop() const;

    inline void             SendMessage(    const MESSAGE_TYPE& message,
                                            const MessageLoop_t* sent_from_context )  const;

    inline void             SendMessageAsync(takes MESSAGE_TYPE* message) const;

    inline void             SendMessageAsync(const MESSAGE_TYPE& message) const;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class AbstractMessageDestination_t
//===
//==================================================================================================
//==================================================================================================


// \cond DOXYGEN_DOCUMENT_NEVER


inline
AbstractMessageDestination_t::AbstractMessageDestination_t()
{
    m_message_loop = NULL;
    // Don't care about the other info...none of it matters without a message loop.
}


inline void
AbstractMessageDestination_t::Set(const AbstractMessageDestination_t& copy)
{
    m_message_loop = copy.m_message_loop;
    m_message_loop_token = copy.m_message_loop_token;
    m_task = copy.m_task;
    m_task_token = copy.m_task_token;
    m_receiver = copy.m_receiver;
}


inline const AbstractMessageDestination_t&
AbstractMessageDestination_t::operator=(const AbstractMessageDestination_t& copy)
{
    m_message_loop = copy.m_message_loop;
    m_message_loop_token = copy.m_message_loop_token;
    m_task = copy.m_task;
    m_task_token = copy.m_task_token;
    m_receiver = copy.m_receiver;
    return *this;
}


inline bool
AbstractMessageDestination_t::IsValid() const
{
    return (m_message_loop != NULL);
    // Don't care about the other info...none of it matters without a message loop.
}


inline void
AbstractMessageDestination_t::Invalidate()
{
    m_message_loop = NULL;
    // Don't care about the other info...none of it matters without a message loop.
}


inline MessageLoop_t*
AbstractMessageDestination_t::MessageLoop() const
{
    return m_message_loop;
}


// \endcond




//==================================================================================================
//==================================================================================================
//===
//=== Template function implementations: class MessageDestination_t
//===
//==================================================================================================
//==================================================================================================
template <class MESSAGE_TYPE>
inline
MessageDestination_t<MESSAGE_TYPE>::MessageDestination_t()
: AbstractMessageDestination_t()
{ }


template <class MESSAGE_TYPE>
inline
MessageDestination_t<MESSAGE_TYPE>::MessageDestination_t(
                                                    MessageLoop_t* message_loop,
                                                    Task_t* task,
                                                    MessageTypeReceiver_t<MESSAGE_TYPE>* receiver )
: AbstractMessageDestination_t( message_loop, task, receiver )
{ }


template <class MESSAGE_TYPE>
inline const MessageDestination_t<MESSAGE_TYPE>&
MessageDestination_t<MESSAGE_TYPE>::operator =(const MessageDestination_t<MESSAGE_TYPE>& copy)
{
    Set(copy);
    return *this;
}


template <class MESSAGE_TYPE>
inline bool
MessageDestination_t<MESSAGE_TYPE>::IsValid() const
{
    return AbstractMessageDestination_t::IsValid();
}


template <class MESSAGE_TYPE>
inline void
MessageDestination_t<MESSAGE_TYPE>::Invalidate()
{
    AbstractMessageDestination_t::Invalidate();
}


template <class MESSAGE_TYPE>
inline MessageLoop_t*
MessageDestination_t<MESSAGE_TYPE>::MessageLoop() const
{
    return AbstractMessageDestination_t::MessageLoop();
}


template <class MESSAGE_TYPE>
inline void
MessageDestination_t<MESSAGE_TYPE>::SendMessage(    const MESSAGE_TYPE& message,
                                                    const MessageLoop_t* sent_from_context ) const
{
    AbstractMessageDestination_t::SendMessage( message, sent_from_context );
}


template <class MESSAGE_TYPE>
inline void
MessageDestination_t<MESSAGE_TYPE>::SendMessageAsync(takes MESSAGE_TYPE* message) const
{
    AbstractMessageDestination_t::SendMessageAsync(message);
}


template <class MESSAGE_TYPE>
inline void
MessageDestination_t<MESSAGE_TYPE>::SendMessageAsync(const MESSAGE_TYPE& message) const
{
    AbstractMessageDestination_t::SendMessageAsync( message.Clone() );
}


#endif // _UT_MESSAGE_DESTINATION_H_