MercuryMessages.h

Go to the documentation of this file.

#ifndef _MERCURYMESSAGES_H
#define _MERCURYMESSAGES_H

#include "global.h"
#include <map>
#include "MercuryCommands.h"
#include "MercuryThreads.h"
#include "MercuryCallback.h"
#include "MercuryVector.h"
#include "MHeap.h"

#include <queue>

void* AutoUpdateMessages( void * data );

class MercuryMessageManager
{
public:
    MercuryMessageManager();

    void Subscribe( const MString &name, MercuryCallback cb );

    void Unsubscribe( const MString &name, MercuryCallback cb );

    void BroadcastMessage( const MString &name, const PStack& args);

    void PostSystemMessage( const MString &name, const PStack& args, float fTimeInFuture = 0 );

    void Update( float fDeltaTime );

    inline void SetupThread() { m_thread.Create(AutoUpdateMessages, this); }
private:
    struct PostData
    {
        PostData(float t = 0, const MString& n = "", const PStack& stack = PStack())
            :time(t), name(n), data(stack)
        {}
        float time;
        MString name;
        PStack data;
        bool operator<(const PostData& t) const
        {
            return time < t.time;
        }
        bool operator>(const PostData& t) const
        {
            return time > t.time;
        }
    };
    volatile std::map < MString, MVector< MercuryCallback > > m_mCallbacks;
    volatile MHeap< PostData > m_mPostCodes;

    //These do not need protection because they are used within protected functions
    float           m_fTotalTime;

    MercuryThread m_thread;

    //I seperated these mutexes because posting a message does not involve
    //callbacks so we can keep running elsewhere while posting
    MercuryMutex    m_mutexCallback; //mutex used for m_mCallbacks
    MercuryMutex    m_mutexPost; //Mutex used for m_mPostCodes, m_mPostedNames, m_mPostedData
};

extern MercuryMessageManager    *MESSAGEMAN;



class MercuryMessageSubscription
{
public:
    MercuryMessageSubscription( ); 
    MercuryMessageSubscription( const MString &name, MercuryCallback cb ); 
    ~MercuryMessageSubscription(); 
    void Subscribe( const MString &name, MercuryCallback cb );
    void Unsubscribe( );
private:
    MString         m_sName;
    MercuryCallback m_pCallback;
};

class MercuryMessageHandler;

struct MercuryMessageObjectData
{
    int             m_iNumber;
    MercuryMessageHandler*  m_qHandler;
};

struct MercuryMessageObjectSubscription
{
public:
    MercuryMessageObjectSubscription( const MString &sName, MercuryMessageObjectData data, MercuryCallbackFunction handler );
    ~MercuryMessageObjectSubscription();
    inline const MString& GetName() const { return m_sName; }
    bool TestOwner(const MString& name, void* handler) const { if ((name == m_sName) && (m_pData.m_qHandler == handler)) { return true; } return false; }
private:
    MString         m_sName;
    MercuryCallback m_pCallback;
    MercuryMessageObjectData    m_pData;
};

class MercuryMessageHandler : public MercuryCommandHandler
{
public:
    virtual void Message( int Message, PStack & data, const MString & name ) {};

    static  void ProcessMessage( const MString & name, void * mudata, PStack & data );

    void RegisterMessage( int messageID, const MString & name );

    void UnregisterMessage( int messageID, const MString & name );

    CLASS_RTTI( MercuryMessageHandler, MercuryCommandHandler );
private:
    MDeque< MAutoPtr<MercuryMessageObjectSubscription> > m_lCallbacks;
};

#define REGISTER_STATEMENT_TO_MESSAGE( type, message, code ) \
    void stregister_##type( const MString &message, void * info, PStack & args ) \
    { \
    code \
    } \
    MercuryMessageSubscription sub##type( #message, MercuryCallback( stregister_##type, 0 ) );

//For DLL applications where the client cannot use C++ class exports.
void HGEXPORT BroadcastPreExisting( const char * sMessageName, int iMPStack );

#endif

/* 
 * Copyright (c) 2005-2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by