execCmds.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2008 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: execCmds.h,v $ $Revision: 1.2 $ $State: Exp $
*******************************************************************************/

#ifndef DtRtiExecCmdFunctor_H_
#define DtRtiExecCmdFunctor_H_

#include <rtiMsConfig.h>
#include <rtiMsg.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlInetAddr.h>
#include <memory>
#include <typeinfo>

class DtRtiExec;
class DtRtiMsg;


class DT_DLL_EXEC DtRtiExecCmd
{
public:

   DtRtiExecCmd() {}
   virtual ~DtRtiExecCmd() {}
   virtual DtRtiExecCmd* clone() const = 0;
   virtual void operator()( const DtRtiExec& exec ) = 0;

   virtual bool operator==( const DtRtiExecCmd& value )
   {
      if ( typeid(*this) == typeid(value) )
      {
         return true;
      }
      else
      {
         return false;
      }
   }
};

class DT_DLL_EXEC DtDeleteFederateCmd : public DtRtiExecCmd
{
public:
   DtDeleteFederateCmd( const DtString& fedexName, int fedHandle ) :
      DtRtiExecCmd(), myFedexName( fedexName ), myFederateHandle( fedHandle ) {}

   virtual ~DtDeleteFederateCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtDeleteFederateCmd( myFedexName, myFederateHandle ); }

   DtString     myFedexName;
   int          myFederateHandle;
};

class DT_DLL_EXEC DtEnableDisableNetworkTestingCmd : public DtRtiExecCmd
{
public:
   DtEnableDisableNetworkTestingCmd( const DtString& fedexName, bool enabled ) :
      DtRtiExecCmd(), myFedexName( fedexName), myEnabled (enabled ) {}

   virtual ~DtEnableDisableNetworkTestingCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtEnableDisableNetworkTestingCmd( myFedexName, myEnabled ); }

   DtString myFedexName;
   bool myEnabled;
};


class DT_DLL_EXEC DtDestroyFederationCmd : public DtRtiExecCmd
{
public:
   DtDestroyFederationCmd( const DtString& fedexName, int fedexHandle ) :
      DtRtiExecCmd(), myFedexName( fedexName ), myFedexHandle( fedexHandle ) {}

   virtual ~DtDestroyFederationCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtDestroyFederationCmd( myFedexName, myFedexHandle ); }

   DtString     myFedexName;
   int          myFedexHandle;
};

class DT_DLL_EXEC DtChangeRidParamCmd : public DtRtiExecCmd
{
public:
   DtChangeRidParamCmd( const DtString& fedexName, int fedHandle ,
      const DtString& ridParam, const DtString& ridValue) :
      DtRtiExecCmd(), myFedexName( fedexName ), myFederateHandle( fedHandle ),
      myRidParam(ridParam), myRidValue(ridValue) {}

   virtual ~DtChangeRidParamCmd() {};
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtChangeRidParamCmd( myFedexName, myFederateHandle, myRidParam, myRidValue ); }

   DtString     myFedexName;
   int          myFederateHandle;
   DtString     myRidParam;
   DtString     myRidValue;
};



class DT_DLL_EXEC DtSendMessageCmd : public DtRtiExecCmd
{
public:
   DtSendMessageCmd( const DtString& fedexName, std::auto_ptr<DtRtiMsg> msg ) :
      DtRtiExecCmd(), myFedexName( fedexName ), myMsg( msg ) {}

   virtual ~DtSendMessageCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtSendMessageCmd( myFedexName, std::auto_ptr<DtRtiMsg>( myMsg->clone( true ))); }

   DtString                myFedexName;
   std::auto_ptr<DtRtiMsg> myMsg;
};


class DT_DLL_EXEC DtChangeNotifyLevelCmd : public DtRtiExecCmd
{
public:
   DtChangeNotifyLevelCmd( DtNotifyLevelType level ) :
      DtRtiExecCmd(), myLevel( level ) {}

   virtual ~DtChangeNotifyLevelCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtChangeNotifyLevelCmd( myLevel ); }

   DtNotifyLevelType  myLevel;
};


class DT_DLL_EXEC DtEnableWebSpyCmd : public DtRtiExecCmd
{
public:
   DtEnableWebSpyCmd( MAKRti::DtInetAddr ipAddr, int port ) :
      DtRtiExecCmd(), myWebSpyIpAddr( ipAddr ), myWebSpyPort( port ) {}

   virtual ~DtEnableWebSpyCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtEnableWebSpyCmd( myWebSpyIpAddr, myWebSpyPort ); }

   MAKRti::DtInetAddr myWebSpyIpAddr;
   int myWebSpyPort;
};


class DT_DLL_EXEC DtLatencyTestModeCmd : public DtRtiExecCmd
{
public:
   DtLatencyTestModeCmd( const DtString& fedexName, int fedHandle, 
      bool runTest, bool continuousType, bool shouldHaltContinuous,
      bool observing, unsigned int interactionPeriod,
      unsigned int numInteractions, unsigned int payloadBytes ) :
      DtRtiExecCmd(), myFedexName( fedexName ), 
      myFederateHandle( fedHandle ), myRunTest( runTest ),
      myContinuousType( continuousType ),
      myShouldHaltContinuous( shouldHaltContinuous ), 
      myObserving( observing ),
      myInteractionPeriod( interactionPeriod ), 
      myNumInteractions( numInteractions ),
      myPayloadBytes( payloadBytes ) {}

   virtual ~DtLatencyTestModeCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtLatencyTestModeCmd( myFedexName, myFederateHandle, 
      myRunTest, myContinuousType, myShouldHaltContinuous, myObserving,
      myInteractionPeriod, myNumInteractions, myPayloadBytes ); }

   DtString     myFedexName;
   int          myFederateHandle;
   bool         myRunTest;
   bool         myContinuousType;
   bool         myShouldHaltContinuous;
   bool         myObserving;
   unsigned int myInteractionPeriod;
   unsigned int myNumInteractions; 
   unsigned int myPayloadBytes;
};


class DT_DLL_EXEC DtEnableLogCmd : public DtRtiExecCmd
{
public:
   DtEnableLogCmd() {}
   virtual ~DtEnableLogCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtEnableLogCmd; }
};


class DT_DLL_EXEC DtExitCmd : public DtRtiExecCmd
{
public:
   DtExitCmd() {}
   virtual ~DtExitCmd() {}
   virtual void operator()( const DtRtiExec& exec );
   virtual DtRtiExecCmd* clone() const
      { return new DtExitCmd; }

};



#endif