OMKEventCreator.cpp

Go to the documentation of this file.

#include "OMKEventCreator.h"
#include "OMKEvent.h"
#include <map>
#include "OMKTracer.h"
using namespace std ;
using namespace OMK ;

EventCreator::EventCreatorContainerType * EventCreator::getEventCreatorContainer()
{
   static EventCreatorContainerType * realEventCreatorContainer = new EventCreatorContainerType () ;
   return realEventCreatorContainer ;
}

void EventCreator::declareAlias( const Name & name1, const Name & name2 )
{
   static map <const Name, const Name> unInsertedAliases ;
   Name nameToInsert ;

   //first find the event creator
   EventCreatorContainerType::iterator i = getEventCreatorContainer()->find ( name1 ) ;
   nameToInsert = name2 ;
   if ( i == getEventCreatorContainer()->end() )
      {
         i = getEventCreatorContainer()->find ( name2 ) ;
         nameToInsert = name1 ;
      }
   if ( i == getEventCreatorContainer()->end() )
      {
         // remember the declaration
         unInsertedAliases.insert (pair<const Name, const Name> (name1, name2) ) ;
         unInsertedAliases.insert (pair<const Name, const Name> (name2, name1) ) ;
      }   
   else
      {
         getEventCreatorContainer()->insert (EventCreator::EventCreatorContainerType::value_type (nameToInsert, (*i).second ) ) ;

         //look in the uninserted aliases if one could not be inserted
         map <const Name, const Name>::iterator j = unInsertedAliases.find ( name1 );
         if ( j == unInsertedAliases.end() )
            {
               j =  unInsertedAliases.find ( name2 );
            }
         if ( j != unInsertedAliases.end() )
            {
               getEventCreatorContainer()->insert (EventCreator::EventCreatorContainerType::value_type ( (*j).second, (*i).second ) ) ;
                  // remove the 2 instances declaring name and (*j).second as aliases
               unInsertedAliases.erase ( unInsertedAliases.find ( (*j).second ) ) ;
               unInsertedAliases.erase ( j ) ; 
            }
      }
}


EventCreator::EventCreator ( const Name & className ) :
   _typeICanCreate ( className ) 
{
   //   cerr<<"EventCreator::EventCreator inserting "<<className<<" in the map of events that can be created from their name"<<endl;
   getEventCreatorContainer()->insert( EventCreator::EventCreatorContainerType::value_type( className, this ) ) ;
}



EventCreator::~EventCreator () 
{
   getEventCreatorContainer()->erase ( _typeICanCreate ) ;
}



Event * EventCreator::createEvent (const Name & classToCreate, const EventIdentifier & eventId, const Date & date, const Name & sender, const Name & receiver ) 
{
   EventCreatorContainerType::iterator i = getEventCreatorContainer()->find (classToCreate) ;

   if ( i == getEventCreatorContainer()->end() )
      {
         cerr<<"EventCreator::createEvent "<<getEventCreatorContainer()->size()<<" event creators in the map"<<endl;
         cerr<<"EventCreator::createEvent: cannot create valued event of class "<<classToCreate
             <<" but I can create: ";
         for ( i = getEventCreatorContainer()->begin() ;
               i != getEventCreatorContainer()->end() ;
               ++i)
            {
               OMASSERTM( (*i).first != classToCreate, "" ) ;
               cerr<<(*i).first<<"("<<(*i).second<<"), ";
            }
         cerr<<endl;
         cerr<<"If in heterogeneous environment try calling EventCreator:::declareAlias ( "<<classToCreate<<", ...) ; in main"<<endl;
         cerr<<"Or, if using g++ with version < 3, a call to "<<classToCreate<<"::myEventCreator::touch()"<<endl;
      }


   return (*i).second->createRealEvent (eventId,date,sender,receiver) ;

}



Event * EventCreator::createRealEvent (const EventIdentifier & eventId, const Date & date, const Name & sender, const Name & receiver ) 
{
   return new Event (eventId, date, sender, receiver) ;
}

---