timeMgr.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: timeMgr.h,v $ $Revision: 1.59 $ $State: Exp $
*********************************************************************/

#ifndef timeMgr_H_
#define timeMgr_H_
#ifdef DtTIME


#include "rtiApiTypes.h"
#include <vlutil/vlFedTarget.h>
#include <vlutil/vlList.h>
#include "disableMsg.h"
#include <queue>

class DtRtiSaveFile;
class DtTimeMgr;
class DtConnectionMgr;
class DtFomClassMgr;
class DtRIDParameters;
class DtFederateMgr;
class DtLogicalTimeFactory;
class DtRtiMsgQueue;
class DtRetractInfoList;
class DtRegulationEnabledMsg;
class DtConstrainedEnabledMsg;
class DtLbtsMsg;
class DtNerLbtsMsg;
class DtSyncConstrainedMsg;
class DtResumeConstrainedMsg;
class DtRetractMsg;
class DtSaveTimeMsg;
class DtSaveInitiateConstrainedMsg;
class DtInitiatedSaveMsg;

class DT_DLL_LRC DtTimeMgr
{
public:
   typedef DtTimeMgr* (*DtTimeMgrCreator)(DtFederateMgr* fedMgr);

protected:

   DtTimeMgr(DtFederateMgr* fedMgr);

public:

   virtual ~DtTimeMgr();

private:
   
   DtTimeMgr(DtTimeMgr const& );

   DtTimeMgr& operator= (DtTimeMgr const& );

public:

   virtual void preTick();

   virtual void postTick();

   virtual void postJoinInit();

   virtual bool isPostJoined() const;

   void testSaveTime(DtRtiApiTime const & timeVal);

   bool validTsoSendTime(DtRtiApiTime const & timeVal);

   bool validRetractTime(DtRtiApiTime const & timeVal);

   virtual void setTime(DtRtiApiTime const & theTime);
   virtual DtRtiApiTime const & time() const;

   virtual void setLookahead(DtRtiApiTimeInterval const & theInterval);
   virtual DtRtiApiTimeInterval const & lookahead() const;

   virtual void setLits(DtRtiApiTime const & theTime);
   virtual DtRtiApiTime const & lits() const;
   virtual DtRtiApiTime const & lots() const;

   virtual bool galtIsValid() const;

   virtual void setGalt(DtRtiApiTime const & theTime);
   virtual DtRtiApiTime const & galt() const;

   virtual void setFederationLbts(DtRtiApiTime const & theTime);
   virtual DtRtiApiTime const & federationLbts() const;

   virtual void setRequestedTime(DtRtiApiTime const & theTime);
   virtual DtRtiApiTime const & requestedTime() const;

   virtual void setRequestedLookahead(
      DtRtiApiTimeInterval const & theInterval);
   virtual DtRtiApiTimeInterval const & requestedLookahead() const;

   virtual void setWorkingLookahead(DtRtiApiTimeInterval const & theInterval);
   virtual DtRtiApiTimeInterval const & workingLookahead() const;

   virtual void setPendingGrant(DtRtiApiTime const & theTime);
   virtual DtRtiApiTime const & pendingGrant() const;

   virtual void setEventTime(DtRtiApiTime const & theTime);
   virtual DtRtiApiTime const & eventTime() const;

   virtual bool getSaveTime(DtRtiApiTime & saveTimeValue ) const;
   virtual void setSaveTime(DtRtiApiTime const & time);

   virtual void resetSaveTime(bool completedSuccessfully);

   virtual bool getLastSaveTime(DtRtiApiTime & saveTime ) const;
   virtual void setLastSaveTime(DtRtiApiTime const & time);




#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
   virtual void enableTimeRegulation(DtRtiApiTimeInterval const & theLookahead);
#else
   virtual void enableTimeRegulation(
      DtRtiApiTime const & theFederateTime,
      DtRtiApiTimeInterval const & theLookahead);
#endif

   virtual void disableTimeRegulation();

   virtual void enableTimeConstrained();

   virtual void disableTimeConstrained();

   virtual void timeAdvanceRequest(DtRtiApiTime const & theTime);

   virtual void timeAdvanceRequestAvailable(DtRtiApiTime const & theTime);

   virtual void nextEventRequest(DtRtiApiTime const & theTime);

   virtual void nextEventRequestAvailable(DtRtiApiTime const & theTime);

   virtual void flushQueueRequest(DtRtiApiTime const & theTime);

   virtual void enableAsynchronousDelivery();

   virtual void disableAsynchronousDelivery();

   virtual bool queryLBTS(DtRtiApiTime& theTime,
      bool testForExceptions=true);

   virtual bool queryFederateTime(DtRtiApiTime& theTime,
      bool testForExceptions=true);

   virtual bool queryMinNextEventTime(DtRtiApiTime& theTime,
      bool testForExceptions=true);

   virtual void modifyLookahead(DtRtiApiTimeInterval const & theLookahead);

   virtual bool queryLookahead (
      DtRtiApiTimeInterval& theInterval,
      bool testForExceptions=true);

   virtual void retract (
      DtMessageRetractionHandle theHandle);

   virtual bool save(DtRtiSaveFile& file);

   virtual void prepareToRestore();

   virtual bool restore( DtRtiSaveFile& file );

   virtual void saveFinished();

   virtual void postSaveFinished();

   virtual void processSaveInitiate();

   virtual bool timeAdvancing() const;

   virtual DtFederateMgr* federateMgr();
   virtual DtFederateMgr* federateMgr() const;

   virtual DtConnectionMgr* connectMgr();
   virtual DtConnectionMgr* connectMgr() const;

   virtual DtRIDParameters* params();
   virtual DtRIDParameters* params() const;

   virtual DtFomClassMgr* fom();
   virtual DtFomClassMgr* fom() const;

   virtual unsigned long nextSerialNumber();

   virtual bool isTimeRegulating() const;
   virtual bool isTimeConstrained() const;

   virtual bool tsoEventWasServiced() const;
   virtual void setTsoEventWasServiced(bool eventServiced);

   virtual bool timeAvailable() const;

public:

   static DtTimeMgr* create(DtFederateMgr* fedMgr);

   static void setCreatorFunction(DtTimeMgrCreator creator);

protected:

   // Time advancing state relies on the state of 2 variables
   // but to support save/restore backwards compatibility they are merged into one enum
   enum DtTimeAvailableState
   {
      // The old state values
      DtTimeNotAvailable = 0,
      DtTimeAvailable,
      // The new state values
      DtTimeNotAvailableAndNotAdvancingAvailable,
      DtTimeNotAvailableAndAdvancingAvailable,
      DtTimeAvailableAndNotAdvancingAvailable,
      DtTimeAvailableAndAdvancingAvailable
   };



   virtual void sendEnableTimeRegulationMsg(DtRtiApiTime const & theTime,
      DtRtiApiTimeInterval const & theLookahead);

   virtual void sendEnableTimeConstrainedMsg(DtRtiApiTime const & theTime,
      DtRtiApiTimeInterval const & theLookahead);

   virtual void sendTimeAdvanceRequestMsg(DtRtiApiTime const & theTime,
      DtRtiApiTimeInterval const & theLookahead);

   virtual void sendConstrainedSyncMsg(DtRtiApiTime const & theTime,
      DtRtiApiTimeInterval const & theLookahead);

   virtual void sendNextEventRequestMsg(DtRtiApiTime const & nerTime,
      DtRtiApiTimeInterval const & nerLookahead, bool isWaitingForEvent, bool isTimeAvailable,
      unsigned long nerCycle);

   virtual void sendDisableMsg(DtTimeServiceType type);

   virtual void sendRetractMsg(const unsigned long serialNumberVal);

   virtual void sendSaveTimeAdvanceMsg();

   virtual void sendInitiatedSaveMsg();


   virtual bool advanceTime(DtRtiApiTime const & newTime);

   virtual void invokeGrant(DtRtiApiTime const & newTime);

   virtual void setTimeAdvancing(bool isAdvancing);

   virtual void setTimeAvailableState(DtTimeAvailableState timeAvailableState);

   virtual DtTimeAvailableState timeAvailableState() const;

   virtual void adjustZeroLookahead(bool forceAdjust=false);

   virtual void resetZeroLookahead();

   void reduceLookahead(DtRtiApiTime const & requestTime);

   void commitLookaheadModifcation();

   virtual bool canGrantImmediately(DtRtiApiTime const & theTime);

   virtual bool timeForSave(DtRtiApiTime const & requestTime);

   bool canGrantImmediately(DtRtiApiTime const & timeVal,
      DtRtiApiTime const & galtVal);

   bool canDeliverImmediately(DtRtiApiTime const & timeVal,
      DtRtiApiTime const & galtVal);

   virtual void checkGalt(bool sendLbtsMsg);

   virtual void checkTimedSave();

   virtual bool checkMsgQueue(DtRtiApiTime const & timeUpperBound,
      DtRtiApiTime & minimumTimestamp);


   virtual bool checkMsgQueue(DtRtiApiTime const & timeUpperBound);

   virtual void processNextTsoEvents(
      DtRtiApiTime const & timeUpperBound, DtRtiApiTime& msgTime,
      DtRtiApiTime const & galtVal);

   virtual void flushMsgQueue(DtRtiApiTime const & requestTime);

   virtual void checkTimeAdvanceRequest();


   virtual void checkNextEventRequest();

   virtual void sendNerMessage();



   virtual void processRegulationEnabled(const DtRegulationEnabledMsg& msg);

   virtual void processConstrainedEnabled(const DtConstrainedEnabledMsg& msg);

   virtual void processLbts(const DtLbtsMsg& msg);

   virtual void processNerLbts(const DtNerLbtsMsg& msg);

   virtual void processSyncConstrained(const DtSyncConstrainedMsg& msg);

   virtual void processResumeConstrained(const DtResumeConstrainedMsg& msg);

   virtual void processRetract(const DtRetractMsg& msg);

   virtual void processSaveTime(const DtSaveTimeMsg& msg);

   virtual void processSaveInitiateConstrained(const DtSaveInitiateConstrainedMsg& msg);

   void processLbts(DtFederateHandle laggardFederate,
      DtRtiApiTime const & lbts, DtRtiApiTime const & lagLbts, bool nerlbts);

   virtual int sizeNeededForVariant();

   virtual DtRtiApiTime& getTempTime();
   virtual void putTempTime(DtRtiApiTime& timePtr);

   virtual void destroyTempTimePool();

protected:



   static void processRegulationEnabled(const DtRegulationEnabledMsg& msg, void* usr);

   static void processConstrainedEnabled(const DtConstrainedEnabledMsg& msg, void* usr);

   static void processLbts(const DtLbtsMsg& msg, void* usr);

   static void processNerLbts(const DtNerLbtsMsg& msg, void* usr);

   static void processSyncConstrained(const DtSyncConstrainedMsg& msg, void* usr);

   static void processResumeConstrained(const DtResumeConstrainedMsg& msg, void* usr);

   static void processRetract(const DtRetractMsg& msg, void* usr);

   static void processSaveTime(const DtSaveTimeMsg& msg, void* usr);

   static void processSaveInitiateConstrained(const DtSaveInitiateConstrainedMsg& msg, void* usr);

protected:

   DtFederateMgr* myFederateMgr;

   bool myIsJoined;

   DtRtiMsgQueue* myMsgQueue;

   DtLogicalTimeFactory* myLogicalTimeFactory;

   bool myGaltIsValid;

   bool myLastSaveTimeIsValid;



   std::auto_ptr <DtRtiApiTime> myLits;

   std::auto_ptr <DtRtiApiTime> myLots;

   std::auto_ptr <DtRtiApiTime> myGalt;
   bool myLbtsIsFromNer;

   std::auto_ptr <DtRtiApiTime> myFederationLbts;

   std::auto_ptr <DtRtiApiTime> myFederateTime;

   std::auto_ptr <DtRtiApiTimeInterval> myLookahead;

   std::auto_ptr <DtRtiApiTime> myRequestedTime;

   std::auto_ptr <DtRtiApiTimeInterval> myRequestedLookahead;

   std::auto_ptr <DtRtiApiTime> myEventTime;

   std::auto_ptr <DtRtiApiTimeInterval> myWorkingLookahead;

   std::auto_ptr <DtRtiApiTime> myPendingGrantTime;

   std::auto_ptr <DtRtiApiTime> mySaveTime;

   std::auto_ptr <DtRtiApiTime> myLastSaveTime;

   bool myEventWasDelivered;

   bool myIncludeEventTime;

   unsigned long myNerCycle;

   bool myPendingGrant;

   bool myInterruptedNextEvent;


   bool myTimeConstrainedEnabled;
   bool myTimeRegulatingEnabled;
   bool myEnableTimeRegulationPending;
   bool myEnableTimeConstrainedPending;
   bool myPendingConstrainedSync;


   bool myCheckGalt;
   bool myRequestingTimeAdvance;
   bool myRequestingNextEvent;
   bool myFlushQueue;
   bool myAdvancingTime;
   bool myTsoEventWasServiced;


   DtTimeAvailableState myTimeAvailableState;
   bool myAdjustedLookahead;
   bool myAdjustedWorkingLookahead;
   bool myModifyingLookahead;
   bool myNeraRemovedLookaheadAdjustment;
   bool myAdvanceWillReduceLookahead;


   bool mySaveTimePending;
   bool mySaveTimeAdvancedPending;
   bool mySavePending;
   bool mySaveTimeIsReady;
   bool myPostSavePending;
   bool myPostSaveTimePending;
   bool myInitateSaveReady;

   MAKRti::DtString mySaveTimeLabel;

   unsigned long mySerialNumber;

   DtRetractInfoList* myRetractList;

   std::queue<DtRtiApiTime*> myTempTimePool;
   // MAKRti::DtList myTempTimePool;

protected:

   static DtTimeMgrCreator theCreator;
};

#endif
#endif