distributorThreadEvents.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2007 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: distributorThreadEvents.h,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/


#ifndef DtDistributorThreadEvents_H_
#define DtDistributorThreadEvents_H_

#include <rtiMsConfig.h>
#include <memory>
#include <typeinfo>
#include <vector>
#include <map>
#include <vlutil/vlString.h>
#include "rtiMsg.h"
#include "fomModuleRequestMsg.h"
#include "fomModuleDistributionMsg.h"

class DtFedExec;
class DtAsyncFileDistributorRunnable;
class DtRtiExecFederateMgr;
class DtFileInformation;
class DtRtiExecFederateMgr;
class DtFomModuleDistributionMsg;
class DtFomModuleRequestMsg;
class DtFederate;


//base class enforces clone() ability
class DT_DLL_EXEC DtDistributorThreadEvent
{
public:

   virtual ~DtDistributorThreadEvent() {}
   virtual DtDistributorThreadEvent* clone() const = 0;

   virtual bool operator==( const DtDistributorThreadEvent& value )
   {
      return ( typeid( *this ) == typeid( value ));
   }

   virtual void processResults() {}
};



class DT_DLL_EXEC DtFedExecDistribFunctor : public DtDistributorThreadEvent
{
public:

   virtual ~DtFedExecDistribFunctor() {};
   virtual void operator()( const DtAsyncFileDistributorRunnable& dist ) = 0;
};


class DT_DLL_EXEC DtGetFileFromDistributorCmd : public DtFedExecDistribFunctor
{
public:
   DtGetFileFromDistributorCmd( const std::vector<DtString>& fileNames, 
      const unsigned long ID) :
   DtFedExecDistribFunctor(), myFileNames ( fileNames ), myInitiatorID(ID)  {}

   virtual ~DtGetFileFromDistributorCmd() {}
   virtual void operator()(const DtAsyncFileDistributorRunnable& dist );
   virtual DtDistributorThreadEvent* clone() const
   { return new DtGetFileFromDistributorCmd(myFileNames, myInitiatorID); }

   virtual void processResults();

   std::vector<DtString> myFileNames;
   unsigned long myInitiatorID;
};

class DT_DLL_EXEC DtFedexRemoveFileCmd : public DtFedExecDistribFunctor
{
public:
   DtFedexRemoveFileCmd( unsigned long ID, const std::vector<DtString>& fileNames ) :
      DtFedExecDistribFunctor(), myFileNames( fileNames), myInitiatorID(ID) {}
      virtual ~DtFedexRemoveFileCmd() {}
      virtual void operator()(const DtAsyncFileDistributorRunnable& dist );
      virtual DtDistributorThreadEvent* clone() const
      { return new DtFedexRemoveFileCmd(myInitiatorID, myFileNames); }

      std::vector<DtString> myFileNames;
      unsigned long myInitiatorID;
};

class DT_DLL_EXEC DtPushFilesToAllFederatesCmd : public DtFedExecDistribFunctor
{
public: 
   DtPushFilesToAllFederatesCmd( const DtString fileName, 
                                                       const char* fileBuff, unsigned long fileSize,
      const unsigned int ID ) :
   DtFedExecDistribFunctor(), myFileBuffer(fileBuff), myFileName(fileName), 
      myFileSize(fileSize), myDestination(ID) {}
      virtual ~DtPushFilesToAllFederatesCmd() {}
      virtual void operator()(const DtAsyncFileDistributorRunnable& dist);
      virtual DtDistributorThreadEvent* clone() const
      { return new DtPushFilesToAllFederatesCmd(myFileName, 
                                                                             myFileBuffer, myFileSize, myDestination); }

      const char* myFileBuffer;
      unsigned long myFileSize;
      DtString myFileName;
      unsigned long myDestination;
};


class DT_DLL_EXEC DtDistributionMsgCmd : public DtFedExecDistribFunctor
{
public: 
   DtDistributionMsgCmd(unsigned long ID, const DtFomModuleDistributionMsg msg ) : 
      DtFedExecDistribFunctor( ), myMsg(msg), myInitiatorID(ID) {};

      virtual DtDistributorThreadEvent* clone() const 
      { 
         return new DtDistributionMsgCmd(myInitiatorID, myMsg ); 
      }
      virtual void operator()(const DtAsyncFileDistributorRunnable& dist);
      const DtFomModuleDistributionMsg myMsg;
      unsigned long myInitiatorID;
};


class DT_DLL_EXEC DtFomModuleRequestMsgCmd : public DtFedExecDistribFunctor
{
public:
   DtFomModuleRequestMsgCmd( unsigned long ID, const DtFomModuleRequestMsg msg ) :
      DtFedExecDistribFunctor(), myMsg(msg), myInitiatorID(ID) {};
      virtual DtFomModuleRequestMsgCmd* clone() const
      {
         return new DtFomModuleRequestMsgCmd(myInitiatorID, myMsg);
      }
      virtual void operator()(const DtAsyncFileDistributorRunnable& dist);
      const DtFomModuleRequestMsg myMsg;
      unsigned long myInitiatorID;
};

class DT_DLL_EXEC DtFedexTakeFileCmd : public DtFedExecDistribFunctor
{
public:
   DtFedexTakeFileCmd( unsigned long ID,
      const std::map<DtString, DtFileInformation*>& files ) : 
   DtFedExecDistribFunctor( ),
      myFiles(files), myInitiatorID(ID) {};
   static DtFedexTakeFileCmd* createNamesOnlyTakeFileEvent(DtFedExec* parent, 
      const std::vector<DtString>& fileNames);
   virtual DtDistributorThreadEvent* clone() const 
   { 
      return new DtFedexTakeFileCmd( myInitiatorID, myFiles ); 
   }
   virtual void operator()(const DtAsyncFileDistributorRunnable& dist);
   std::map<DtString, DtFileInformation*> myFiles;
   unsigned long myInitiatorID;
};






//Event Definitions
class DT_DLL_EXEC DtDistribFunctor : public DtDistributorThreadEvent
{
public: 
   virtual ~DtDistribFunctor() {};
   virtual void operator()( const DtAsyncFileDistributorRunnable& dist ) = 0;
};


class DT_DLL_EXEC DtFedexDistributionEvent : public DtDistribFunctor
{
public:
   DtFedexDistributionEvent( DtFedExec* parent ) :
      DtDistribFunctor(), myParent ( parent) { };
   virtual void operator()( const DtAsyncFileDistributorRunnable& dist ) {}   

   DtFedExec* myParent;
};

class DT_DLL_EXEC DtRequestedModulesArrivedEvent : public DtFedexDistributionEvent
{
public: 
   DtRequestedModulesArrivedEvent(DtFedExec* parent ) : 
      DtFedexDistributionEvent( parent ) {};

   virtual DtDistributorThreadEvent* clone() const 
   { 
      return new DtRequestedModulesArrivedEvent( myParent  ); 
   }
   virtual void operator()( const std::vector<DtString>& fileNames);
   virtual void processResults();

   std::vector<DtString> myFileNames;
};

class DT_DLL_EXEC DtFedFileRequestMsgEvent : public DtFedexDistributionEvent
{
public: 
   DtFedFileRequestMsgEvent( DtFedExec* parent ) :
      DtFedexDistributionEvent( parent ) {};
   virtual DtDistributorThreadEvent* clone() const
   {
      return new DtFedFileRequestMsgEvent( myParent );
   }
   virtual void operator()( const std::vector<DtString>& fileNames, unsigned long fedID);
   virtual void processResults();

   std::vector<DtString> myFileNames;
   unsigned long myInitiatingID;
};


class DT_DLL_EXEC DtFedExTakeFileEvent : public DtFedexDistributionEvent
{
public:
   DtFedExTakeFileEvent( DtFedExec* parent ) :
      DtFedexDistributionEvent(parent) {};
      virtual DtDistributorThreadEvent* clone() const { return new DtFedExTakeFileEvent(myParent); }
      virtual void operator()( const std::map<DtString, DtFileInformation*>& fileNames  );
      virtual void processResults();

      std::map<DtString, DtFileInformation*> myFileNames;
};

class DT_DLL_EXEC DtFileRequestedEvent : public DtFedexDistributionEvent
{
public:
   DtFileRequestedEvent( DtFedExec* parent ) :
      DtFedexDistributionEvent(parent) {};
   virtual DtDistributorThreadEvent* clone() const
   {
      return new DtFileRequestedEvent( myParent );
   }
   virtual void operator()( const std::vector<DtString>& files );
   virtual void processResults();

   std::vector<DtString> myFileNames;
};

class DT_DLL_EXEC DtFileReceivedEvent : public DtFedexDistributionEvent
{
public:
   DtFileReceivedEvent( DtFedExec* parent ) :      
      DtFedexDistributionEvent(parent) {};

   virtual DtDistributorThreadEvent* clone() const
   {
      return new DtFileReceivedEvent( myParent );
   }
   virtual void operator()( const DtFomModuleDistributionMsg& msg );
   virtual void processResults();


   DtFomModuleDistributionMsg myMsg;
};

class DT_DLL_EXEC DtPushFedFileToFederatesEvent : public DtFedexDistributionEvent
{
public:
   DtPushFedFileToFederatesEvent( DtFedExec* parent ) :
      DtFedexDistributionEvent( parent ) {};
   virtual DtDistributorThreadEvent* clone() const
   {
      return new DtPushFedFileToFederatesEvent(myParent);
   }
   virtual void operator()(DtString name, int fileSize, const char* buff);
   virtual void processResults();

   DtString myFileName;
   int myFileSize;
   const char* myBuff;
};



class DT_DLL_EXEC DtPushFedFileToSingleFederateEvent : public DtPushFedFileToFederatesEvent
{
public:
   DtPushFedFileToSingleFederateEvent( DtFedExec* parent ) :
      mySingleFederate(0),
      DtPushFedFileToFederatesEvent(parent) {};
      virtual DtDistributorThreadEvent* clone() const
      {
         return new DtPushFedFileToSingleFederateEvent(myParent);
      }
      virtual void operator()(DtString name, int fileSize, const char* buff, DtFederateHandle recipientHandle)
      {
         DtPushFedFileToFederatesEvent::operator ()(name, fileSize, buff);
         mySingleFederate = recipientHandle;
      }
      virtual void processResults();
      DtFederateHandle mySingleFederate;
};





class DT_DLL_EXEC DtDistribFunctorChangeRequest: public DtDistributorThreadEvent
{
public:
   enum EventType {
      RequestedModuleArrived,
      FedFileRequested,
      FedFileReceived,
      PushFedFileToAllFederates,
      PushFedFileToSingleFederate,
      TakeFile,
      UploadToExec,
      RtiMsg,
      BackendExited
   };

   DtDistribFunctorChangeRequest( EventType type,
      const DtDistributorThreadEvent& newFunctor,
      bool addition = true ):
      myType( type ), 
      myAddition( addition ),
      myFunctor( newFunctor.clone() ),
      myMsgKind(),
      myIsMomMsg( false )
   {}

   DtDistribFunctorChangeRequest( EventType type,
      const DtDistributorThreadEvent& newFunctor,
      bool addition,
      DtRtiMsgKind kind,
      bool isMomMsg = false) :
   myType( type ), 
      myAddition( addition ),  
      myFunctor( newFunctor.clone() ),
      myMsgKind( kind ),
      myIsMomMsg( isMomMsg )
   {}

   DtDistribFunctorChangeRequest( const DtDistribFunctorChangeRequest& orig ) :
   myType( orig.myType ), 
      myAddition( orig.myAddition ),  
      myFunctor( orig.myFunctor->clone() ),
      myMsgKind( orig.myMsgKind ),
      myIsMomMsg( orig.myIsMomMsg )
   {}

   virtual ~DtDistribFunctorChangeRequest() { delete myFunctor; myFunctor = 0; }

   virtual DtDistributorThreadEvent* clone() const
   {
      return new DtDistribFunctorChangeRequest( myType, *myFunctor, myAddition,
         myMsgKind, myIsMomMsg );
   }

   virtual DtDistribFunctorChangeRequest& operator=( const DtDistribFunctorChangeRequest& orig )
   {
      if ( this == &orig ) return *this;

      DtDistributorThreadEvent* copy = orig.myFunctor->clone();
      myFunctor  = copy;
      myType     = orig.myType;
      myAddition = orig.myAddition;
      myMsgKind  = orig.myMsgKind;
      myIsMomMsg = orig.myIsMomMsg;

      return *this;
   }


   EventType          myType;
   bool               myAddition;
   DtDistributorThreadEvent* myFunctor;
   DtRtiMsgKind       myMsgKind;   
   bool                    myIsMomMsg;
};




#endif //DtDistributorThreadEvents_H_