MercuryMessages.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryMessages.h"
#include "MercuryThreads.h"
#include "MercuryUtil.h"
#include "MercuryLog.h"

using namespace std;

MercuryMessageManager   *MESSAGEMAN = NULL;

extern volatile float DTIME;

void* AutoUpdateMessages( void * data )
{
    while ( true )
    {
        Sleep(10);
        ((MercuryMessageManager*)data)->Update(DTIME);
    }
    return 0;
}

MercuryMessageManager::MercuryMessageManager()
    :m_fTotalTime( 0 )
{ 
    //no code
}

void MercuryMessageManager::BroadcastMessage( const MString &name, const PStack& data )
{
    MercuryCallback* cb = NULL;
    map < MString, MVector< MercuryCallback > >::iterator mpi;
    MLockPtr<std::map < MString, MVector< MercuryCallback > > > callbacks(m_mCallbacks, m_mutexCallback);

    mpi = callbacks->find(name);

    if ( mpi == callbacks->end() )
        return;

    //make a copy of the vector incase the fector changes
    //during processes (it can becuse of unregister)
//  MVector< MercuryCallback > clbk = mpi->second;

    //XXX FIX ME - very crappy fix
    for ( unsigned int i = 0; i < mpi->second.size() ;)
    {
        unsigned int t = mpi->second.size();
        PStack argscopy = data;
        cb = &(mpi->second[i]); 
        cb->funct( name, cb->luser, argscopy);
        if(mpi->second.size() >= t)
            i++;
    }
}

void MercuryMessageManager::Subscribe( const MString &name, MercuryCallback cb )
{
    MLockPtr<std::map < MString, MVector< MercuryCallback > > >(m_mCallbacks, m_mutexCallback)->operator[](name).push_back(cb);
}

void MercuryMessageManager::Unsubscribe(  const MString &name, MercuryCallback cb )
{
    map < MString, MVector< MercuryCallback > >::iterator mpi;
    MLockPtr<std::map < MString, MVector< MercuryCallback > > > callbacks(m_mCallbacks, m_mutexCallback);
    mpi = callbacks->find( name );

    if ( mpi == callbacks->end() )
        return;

    for( unsigned int i = 0; i < mpi->second.size(); i++ )
        if( mpi->second[i] == cb )
            mpi->second.remove( i );
}

void MercuryMessageManager::PostSystemMessage( const MString &name, const PStack& data, float fTimeInFuture )
{
    MLockPtr<MHeap< PostData > > postCodes(m_mPostCodes, m_mutexPost);
    (*postCodes).push( PostData(fTimeInFuture + m_fTotalTime, name, data) );
}

void MercuryMessageManager::Update( float fDeltaTime ) 
{
    std::map < float, unsigned int >::iterator iterPC;

    MLockPtr<MHeap< PostData > > postCodes(m_mPostCodes, m_mutexPost);

    m_fTotalTime += fDeltaTime;

    while(!postCodes->empty())
    {
        const PostData& pd = postCodes->head();
        if(pd.time <= m_fTotalTime)
        {
            BroadcastMessage( pd.name, pd.data );
            postCodes->pop();
        }
        else
            return;
    }
}

MercuryMessageSubscription::MercuryMessageSubscription()
{
    if ( !MESSAGEMAN )
        MESSAGEMAN = new MercuryMessageManager;
}

MercuryMessageSubscription::MercuryMessageSubscription( const MString &name, MercuryCallback cb )
{
    MercuryMessageSubscription::MercuryMessageSubscription();
    Subscribe( name, cb );
}


MercuryMessageSubscription::~MercuryMessageSubscription()
{
    Unsubscribe( );
}

void MercuryMessageSubscription::Unsubscribe( )
{
    if ( m_pCallback != NULL && MESSAGEMAN )
    {
        MESSAGEMAN->Unsubscribe( m_sName, m_pCallback );
        m_pCallback.funct = NULL;
        m_pCallback.luser = NULL;
        m_sName = "";
    }
}

void MercuryMessageSubscription::Subscribe( const MString &name, MercuryCallback cb )
{
    Unsubscribe( );
    m_sName = name;
    m_pCallback = cb;
    MESSAGEMAN->Subscribe( name, cb );
}

MercuryMessageObjectSubscription::MercuryMessageObjectSubscription( const MString &sName, MercuryMessageObjectData data, MercuryCallbackFunction handler )
{
    m_pData = data;
    m_pCallback.luser = &m_pData;
    m_pCallback.funct = handler;
    m_sName = sName;
    MESSAGEMAN->Subscribe( sName, m_pCallback );
}

MercuryMessageObjectSubscription::~MercuryMessageObjectSubscription()
{
    MESSAGEMAN->Unsubscribe( m_sName, m_pCallback );
}

void MercuryMessageHandler::ProcessMessage( const MString & name, void * mudata, PStack & data )
{
    MercuryMessageObjectData * k = (MercuryMessageObjectData*)mudata;
    k->m_qHandler->Message( k->m_iNumber, data, name );
}

void MercuryMessageHandler::RegisterMessage( int messageID, const MString & name )
{
    MercuryMessageObjectData k;
    k.m_iNumber = messageID;
    k.m_qHandler = this;
    MercuryMessageObjectSubscription * newsub = new MercuryMessageObjectSubscription( name, k , ProcessMessage );
    m_lCallbacks.push_back( newsub );
}

void MercuryMessageHandler::UnregisterMessage( int messageID, const MString & name )
{
    MDequeIterator< MAutoPtr<MercuryMessageObjectSubscription> > i = m_lCallbacks.begin();
    for (i = m_lCallbacks.begin(); i != m_lCallbacks.end(); ++i)
        if ((*(*i)).TestOwner(name, this))
        {
            m_lCallbacks.erase(i);
            return;
        }
}

void HGEXPORT BroadcastPreExisting( const char * sMessageName, int iMPStack )
{
    PStack * s = GetMPStack( iMPStack );
    if ( s )
        MESSAGEMAN->BroadcastMessage( MString( sMessageName ), *s );
}

/* 
 * Copyright (c) 2005-2006 Charles Lohr, Joshua Allen
 * 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