/ray/src/lib/message/manager.cc

Go to the documentation of this file.

/*
 * lib/message/manager.cc
 * 
 * Message handling "system" for errors, warnings and verbose messages. 
 * Message manager implementation. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "manager.h"
#include "handler.h"


// Initializing static data: 
MessageManager *MessageManager::manager=NULL;


void MessageManager::_PostMessage(const Message &m)
{
    if(!this)  return;
    
    // If the message is not needed by any client, we can bail 
    // out early. 
    // Actually, we should not even be here in this case, but oh well...
    if(!_IsRequestedType(m.type()))  return;
    
    main_mutex.lock();
    
    // Deliver to all clients: 
    for(MessageHandler *_hdl=hdl_list.first(); _hdl; )
    {
        // If you don't know why these two lines are here, then leave 
        // them untouched. (They ARE necessary!) 
        MessageHandler *hdl=_hdl;
        _hdl=_hdl->next;
        
        if(m.MatchesTypeMask(hdl->mtmask))
        {  hdl->HandleMessage(m);  }
    }
    
    // In case it is a fatal error, we need to exit. 
    bool is_fatal=(m.type() & Message::MTFatal);
    bool must_exit = is_fatal && exit_on_fatal;
    
    main_mutex.unlock();
    
    if(must_exit)
    {
        // It's time to say goodbye...
        exit(2);
    }
}


void MessageManager::_RecomputeMTMask()
{
    // (NOT mutex-protected!)
    
    // OR together again: 
    int all_mask=0;
    for(MessageHandler *hdl=hdl_list.first(); hdl; hdl=hdl->next)
    {  all_mask|=hdl->mtmask;  }
    
    // Update global type mask. 
    type_mask.set(all_mask);
}


void MessageManager::_SelectMessageTypes(MessageHandler *hdl,
    Message::Type mask)
{
    if(!this)  return;
    
    main_mutex.lock();
    
    // (Needs to be stored; bit removal problem :)
    hdl->mtmask=mask;
    
    _RecomputeMTMask();
    
    main_mutex.unlock();
}


void MessageManager::_RegisterHandler(MessageHandler *hdl)
{
    if(!this || !hdl)  return;
    
    main_mutex.lock();
    hdl->mtmask=Message::MTNone;
    hdl_list.append(hdl);
    main_mutex.unlock();
}

void MessageManager::_UnregisterHandler(MessageHandler *hdl)
{
    if(!this || !hdl)  return;
    
    main_mutex.lock();
    hdl_list.dequeue(hdl);
    _RecomputeMTMask();
    main_mutex.unlock();
}


void MessageManager::init()
{
    // Initialize the manager. 
    new MessageManager();  // <-- Constructor will set MessageManager::manager. 
}


void MessageManager::cleanup()
{
    if(manager)
    {  delete manager;  }
    // manager=NULL here by destructor of MessageManager. 
}


MessageManager::MessageManager() : 
    hdl_list(),
    main_mutex()
{
    // This is needed as we use an atomic integer for mask storage. 
    CritAssert(sizeof(int)>=sizeof(Message::Type));  // critical
    
    type_mask=0;
    
    exit_on_fatal=1;
    
    Assert(!manager);
    manager=this;
}


MessageManager::~MessageManager()
{
    Assert(manager==this);
    
    // Simply ignore the managers in the list. We dequeue them 
    // and leave them alone. 
    main_mutex.lock();
    while(!hdl_list.IsEmpty())
    {  _UnregisterHandler(hdl_list.first());  }
    main_mutex.unlock();
    
    manager=NULL;
}

---