TimeManager.h

Go to the documentation of this file.

#ifndef TIME_MANAGER_H_
#define TIME_MANAGER_H_

#include "syncstatus.h"
#include "SaveStatus.h"

#if defined(_MIPS_SIM)
#pragma set woff 3201
#pragma set woff 1209
#pragma set woff 1424
#pragma set woff 1110
#endif

#include <RTItypes.hh>
#include <fedtime.hh>

#if defined(_MIPS_SIM)
#pragma reset woff 3201
#pragma reset woff 1209
#pragma reset woff 1424
#pragma reset woff 1110
#endif

/** TimeManager - handels the HLA time synchronization.
    The TimeManager creates an interface for the Federate to send time synchronization 
    messages and to receive synchronization messages from the RTI-Ambassador. The
    TimeManager class provides some high level methods for time synchronization - these
    methods generally start with waitFor... e.g. waitForFederationSynchronized or have 
    ...WaitFor... as part of the method name.
    @ingroup ftk
*/
class TimeManager 
{
  public:

    /** This method creates an instance of the TimeManager class if it doesn't exist.
        @return the TimeManager instance.
    */
    static TimeManager &Instance();


    /// Destructor does nothing special.
    ~TimeManager();

    
    /** This method sets the federation time.
        @param time The new federation time.
    */
    void  federationTimeSet(RTIfedTime& time) {_federationTime = time;}


    /** This method returns the federation time.
        @return The federation time.
    */
    RTIfedTime&  federationTimeGet() {return _federationTime;}


    /** This method sets the Federate's local time.
        @param time The new local time.
    */
    void localTimeSet(RTIfedTime& time) {_localTime = time;}


    /** This method returns the Federate's local time.
        @return The Federate's local time.
    */
    RTIfedTime& localTimeGet() {return _localTime;}


    /// This method sets the local and reset time to the Federation time.
    void init();


    /** This method resets the local time to 0.0 clears the synchronization flags
        and restores the flags.
    */
    void reset();


    /** This method enables the time regulation for the Federate.
        @param time The Federation time.
  @param lookahead The time horizont.
    */
    void enableTimeRegulation(const RTIfedTime& time, const RTIfedTime& lookahead);
    

    /// This method disables the time regulation for the Federate.
    void disableTimeRegulation();


    /// This method makes the Federate time constrained.
    void enableTimeConstrained();


    /// This method disables the time constrained condition for the Federate.
    void disableTimeConstrained();


    /** This method implements the HLA time advance request.
        @param theTime The new time the Federate asks to advance to.
    */
    void timeAdvanceRequest(const  RTIfedTime& theTime);


    /** This method implements the HLA time advance available method.
        @param theTime The new time the Federate asks to advance to.
    */  
    void timeAdvanceRequestAvailable(const RTIfedTime& theTime);


    /** This method implements the HLA next event method.
        @param theTime The new time the Federate asks to advance to.
    */  
    void nextEventRequest(const RTIfedTime& theTime);


    /** This method implements the HLA next event available method.
        @param theTime The new time the Federate asks to advance to.
    */  
    void nextEventRequestAvailable(const RTIfedTime& theTime);


    /** This method advances the local time.
        @param requestedTime New local time.
    */
    void advanceLocalTime(const RTIfedTime& requestedTime);


    /** This high-level method requests to advance to the time given and
        waits until the request is granted (or time out).
    */
    void requestTimeAdvanceAndWaitForGrant();

    /// This method requests a time advance to the Federate's local time.
    void requestTimeAdvance();


    /** This method checks if the time advance is granted.
        @return true if the time advance is granted.
    */
    bool isTimeAdvanceGranted();


    /** This method returns the granted flag.
        @return the granted flag.
    */
    bool isGranted() { return _granted; };


    /** This method returns true if the granted flag is set to false.
        @return Flase if granted flag is true.
    */
    bool isAdvancing() { return !_granted; };


    /** This method returns the time horizont.
        @return lookahed.
    */
    RTIfedTime& lookAheadGet() { return _lookAhead; }


    /** This method informs the RTI the the synchronization point has been achieved.
        @param label The synchronization point label.
    */
    void synchronizationPointAchieved(const char *label);
      

    /** This is a high-level method to register a synchronization point and wait 
        for a reply from the RTI.
        @param syncLabel  The synchronization point label.
        @param timeOut The timeout (default 600 seconds)
    */
    bool waitForRegisterSynchronizationPoint(const char* syncLabel, int timeOut = 600);
 

    /** This is a high-level method waits until a specific synchronization point is
        announced by the RTI.
        @param syncLabel  The synchronization point label.
        @param timeOut The timeout (default 600 seconds)
    */
    bool waitForSynchronizationPointAnnounced(const char* syncLabel,
                int timeOut = 600);


    /** This is a high-level method waits until the Federation is synchrnized at a 
        given synchronization point.
        @param syncLabel  The synchronization point label.
        @param timeOut The timeout (default 600 seconds)
    */
    bool waitForFederationSynchronization(const char* syncLabel,
            int timeOut = 600);


    /** This method implements the HLA method, registerSynchronizationSet
        @param syncLabel  The synchronization point label.
        @param syncSet Federate Handle Set.
    */
    void registerSynchronizationSet(const char* syncLabel, 
            const RTI::FederateHandleSet& syncSet);


    /** This method implements the HLA method, synchronizationRegistrationConfirmed
        (from Federate Ambssador). 
        @param syncLabel  The synchronization point label.
     */
    bool synchronizationRegistrationConfirmed(const char* syncLabel);


    /** This method implements the HLA method, synchronizationRegistrationFailed
        (from Federate Ambssador). 
        @param syncLabel  The synchronization point label.
     */
    bool synchronizationRegistrationFailed(const char* syncLabel);


    /** This method implements the HLA synchronizationPointAnnounced
        (from Federate Ambssador). 
        @param syncLabel  The synchronization point label.
     */
    bool synchronizationPointAnnounced(const char* syncLabel);


    /** This method implements the HLA method,federationSynchronized
        (from Federate Ambssador). 
        @param syncLabel  The synchronization point label.
     */
    bool federationSynchronized(const char* syncLabel);


    /** This method implements the HLA method requestFederationSave
        (to the RTI ambassador).
        @param label Synchronization point label.
    */
    void requestFederationSave(string label);


    /** This method implements the HLA method requestFederationSave
        (to the RTI ambassador).
        @param label Synchronization point label.
        @param theTime Requested Federation time for save.
    */
    void requestFederationSave(string label, RTIfedTime& theTime);


    /** This method returns the initSave flag.
        @param label Synchronization point label.
  @return true if a save with this label was initiated.
    */
    bool federateSaveInitiated(const char *label);


    /** This high-level method waits for a FederationSaveInitiated message from the RTI.
        @param syncLabel Synchronization point label.
        @param timeOut Time after which this method returns false (default 600 seconds).
    */
    bool waitForFederateSaveInitiated(string syncLabel, int timeOut = 600);


    /// this method informs the RTI ambassador that Federation save has begun
    void federateSaveBegun();

    /** This method returns the federationSaved label.
        @param label The synchronization point label.
  return True if the Federation is saved.
    */
    bool isFederationSaved(string label);

   
    /** This method returns the federationNotSaved label.
        @param label The synchronization point label.
  return the federationNotSaved label.
    */   
    bool isFederationNotSaved(string label);


    /** This method waits until the Federation is saved.
        @param syncLabel Synchronization point label.
        @param timeOut Time after which this method returns false (default 600 seconds).
    */          
    bool waitForFederationSaved(string syncLabel, int timeOut = 600);


    /** This method requests to restore the Federation to the given synchronization point.
        @param label The synchronization point label.
    */
    void requestFederationRestore(string label);


    /** This method waits until the RTI requests to restore the Federation to a given 
         synchronization point.
         @param syncLabel Synchronization point label.
   @param timeOut Time after which this method returns false (default 600 seconds).
         @return true if the Federation restore request is accepted.
    */                  
    bool waitForRequestFederationRestore(string syncLabel, int timeOut = 600);


    /** This method implemets the HLA RTI Ambassador method federateRestoreComplete.
        It informs the RTI that the Federate has completed its restore.
    */
    void federateRestoreComplete();


    /** This method implemets the HLA RTI Ambassador method federateRestoreNotComplete.
        It informs the RTI that the Federate was unable restore its state.
    */
    void federateRestoreNotComplete();


    // These functions are called by the federateAmbassador
    // ----------------------------------------------------


    /** This method sets the registered flag indicating the the registration succeeded.
        @param label Synchronization point Label.
    */
    void synchronizationPointRegistrationSucceeded(const char *label);


    /** This method sets the failed flag indicating the the registration failed.
        @param label Synchronization point Label.
    */
    void synchronizationPointRegistrationFailed(const char *label);


    /** This method sets the announced flag indicating the the registration has been announced.
        @param label Synchronization point Label.
    */
    void announceSynchronizationPoint(const char *label);


    /** This method sets the confirmed flag indicating that the Federation has been
       synchronized at synchronization point indicated by the label.
       @param label Synchronization point Label.
    */
    void federationSynchronizationConfirmed(const char *label);


    /** This method sets the time regulation flag and the Federtion time,
        indicating that the Fedearte is now time regulating.
        @param time Federation time.
    */
    void timeRegulationEnabled(const RTI::FedTime &time);


    /** This method returns the time regulation flag.
        @return True if the Federate is time regulating.
    */
    bool timeRegulationEnabled() {return _timeRegulationFlag;}


    /** This method sets the time constrained flag and the Federtion time,
        indicating that the Fedearte is now time constrained.
        @param time Federation time.
    */    
    void timeConstrainedEnabled(const RTI::FedTime &time);


    /** This method returns the time constrained flag.
        @return True if the Federate is time constrained.
    */
    bool timeConstrainedEnabled() {return _timeConstrainedFlag;}


    /** This method sets the time advance granted flag and the Federtion time,
        indicating that the Fedeartion time has been advanced to the given time.
        @param time Federation time.
    */    
    void timeAdvanceGrant(const RTI::FedTime &time);


    /** This method checks if the Federate is fully time enabled.
        @return true if both, the timeRegulation and timeConstrained flags are set.
    */
    bool timeEnabled();

       
    /** This method initiates a new save structure. 
        @param label Synchronization point Label.
    */
    void initiateFederateSave(const char *label);


    /// This method sets the saved flag to true on the curren save struct.
    void federationSaved();


    /// This method sets the notSaved flag to true on the curren save struct.
    void federationNotSaved();


    /** This method sets the requestRestore flag to true.
        @param label Synchronization point Label.
    */
    void requestFederationRestoreSucceeded (const char *label);


    /** This method sets the requestRestoreFailed flag to true.
        @param label Synchronization point Label.
  @param reason A string indicating the reason for the failure.
    */
    void requestFederationRestoreFailed (const char *label, const char *reason);


    /** This method sets the requestRestoreFailed flag to true.
        @param label Synchronization point Label.
    */
    void requestFederationRestoreFailed (const char *label);


    /** This method returns the requestRestore flag.
        @param label Synchronization point label.
    */
    bool didRestoreRequestSucceed(string label);


    /** This method returns the requestRestoreFailed flag.
        @param label Synchronization point label.
    */
    bool didRestoreRequestNotSucceed(string label);


    /** This method resets the restored and notRestored flags to false.     
        @param label Synchronization point label.
    */
    void resetRequestFederationRestoreFlags(const char *label);


    /** This method set the restoreBegun flag to true and requests the RFI to
        clear the ReturnValues from the current run.
    */ 
    void federationRestoreBegun();


    /** This method returns the restoreBegun flag.
        @return True if the simulation is resetting to time 0.0.
    */
    bool hasFederationRestoreBegun();


    /** This is a high-level mentod that returns true after the Fedeartion has 
        started a restore or flase if the method timed out.
        @param timeOut Settable timeout, default = 600 secsonds.
    */
    bool waitForFederationRestoreBegun(int timeOut = 600);


    /// This method sets the restoreBegun flag to false.  
    void resetRestoreBegunFlag();


    /** This method returns true if a Federation restore has begun.
        @param label Synchronization point label.
        @return true if the Federation is restored.
    */
    bool restoreFederate(string label);


    /** This method setes the initRestreFlag to true and saves the synchronization 
        point label.
        @param label Synchronization point label.
  @param handle The Federate handle.
    */
    void initiateFederateRestore(const char *label, RTI::FederateHandle handle);


    /** This is a high-level method that returns true when the restore is initiated 
        or false if the method timed out.
  @param syncLabel Synchronization point label.
        @param timeOut Method timeout, default = 600 seconds.
    */
    bool waitForFederateRestoreInitiated(string syncLabel, int timeOut = 600);

    /** This method  returns the initRestore flag.
       @param label Synchronization point label.
        @returns true if the specified restore is initiated.
    */    
    bool isFederateRestoreInitiated(string label);


    /** This method  returns the notInitRestore flag.
        @param label Synchronization point label.
        @returns true if the specified restore request has failed.
    */    
    bool isFederateRestoreNotInitiated(string label);


    /// This method sets the restored flag to true.
    void federationRestored();


    /** This method returns the value of the restored flag.
        @param label Synchronization point label.
        @return true if the Federation is restored.
    */
    bool isFederationRestored(string label);

    
    /** This is a high-level method that returns true when the Federation is 
        restored or false if the method timed out.
  @param syncLabel Synchronization point label.
        @param timeOut Method timeout, default = 600 seconds.
    */
    bool waitForFederationRestored(string syncLabel, int timeOut = 600);


    /// This method sets the notRestored flag to true.    
    void federationNotRestored();

    
    /** This method returns true if the Fedeeration failed to restore.
  @param label Synchronization point label.
        @return true if restore failed.
    */  
    bool isFederationNotRestored(string label);


    /// This method informs the RTI that the Federate has completed its save procedure.  
    void federateSaveComplete();


    /// This method informs the RTI that the Federate has failed its save procedure.  
    void federateSaveNotComplete();

    
    /** This method sets the initSave flag to false.
  @param label Synchronization point label.
    */
    void resetInitSaveFlag(string label);


    /** This method sets the initRestore flag to false.
  @param label Synchronization point label.
    */
    void resetInitRestoreFlag(string label);


    /** This method sets the restored and not Restred flags to false.
  @param label Synchronization point label.
    */
    void resetRestoredFlags(string label);


    /** This method sets all the save and restore flags to false.
  @param label Synchronization point label.
    */
    void resetSaveAndRestoreFlags(string label);


    /** This high-level method returns true when the Federation is synchronized.
  @param label Synchronization point label.
    */
    bool waitForFederationSynchronized(const char* label);


    /** This high-level method returns true when the Federation is synchronized.
  @param label Synchronization point label.
        @param timeOut Method timeout, default = 600 seconds.
    */
     bool waitForFederationSaveSynchronized(const char* label, int timeOut = 600);


    /** This high-level method returns true when the Federation is 
        synchronized hand all Fedeartes hace saved their states 
        or false if the method timed out.
  @param label Synchronization point label.
    */
    bool waitForFederationSynchronizedAndSaved(const char* label);

  private:

    /// Disable constructor.
    TimeManager();

    /// Disable copy constructor.
    TimeManager(const TimeManager&);

    /// Disable assignment operator.
    TimeManager &operator = (const TimeManager&);

    /// Make sure the object gets destroyed when the program exits.
    static void Destroy();

    /// Instance of the TimeManager class.
    static TimeManager *_theTimeManager;

    /// Federation Time.
    RTIfedTime _federationTime;

    /// The Fedearte's local time.
    RTIfedTime _localTime;

    /// The time the Fedeartion will have after a reset (0.0).    
    RTIfedTime _resetTime;

    /// A flag indicating time regulation.
    bool _timeRegulationFlag;

    /// A flag indicating time constrained.
    bool _timeConstrainedFlag;

    /// Label of the current synchronization point.
    string _saveLabel;

    /// A class for managing time synchronization states.  
    SyncStatus _syncStatus;

    /// A class for managing save and restore synchronization states.  
    SaveStatus _saveStatus;

    /// A set of Federate handles that participate in a certain save/restore operation.
    const RTI::FederateHandleSet *_syncSet;

    /// A flag indicating if synchronization restore has begun.
    bool _restoreBegun;

    /// A flag indicating if the time advance request has been granted.
    bool _granted;    

    /// A time indicating the time horizont.
    RTIfedTime _lookAhead;
};

#endif // TIME_MANAGER_H_

---