simpleDDMFederate.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: simpleDDMFederate.h,v $ $Revision: 1.17 $ $State: Exp $
******************************************************************************/

#ifndef REGIONEXAMPLE_H_
#define REGIONEXAMPLE_H_

// Base class for wrappers around the RTI Ambassador calls.

#include <sstream>
#include <string>
#include <iostream>
#include <iomanip>
#include <vector>


#include "simpleDDMStringUtil.h"



class simpleDDMFederate
{
public:
// Default Constructor
   simpleDDMFederate();

// Constructor
   simpleDDMFederate(simpleDDMFederate& data);

// Destructor
   virtual ~simpleDDMFederate();

// RTI Wrappers

// Initialize the RTI
   virtual void initializeRTI() = 0;

// Create a federation execution
   virtual bool createFedEx() = 0;

// Join a federation execution
   virtual bool joinFedEx() = 0;

// Resign from the federation execution and destroy it
   virtual void resignAndDestroy() = 0;

// Create the Region and initialize its bounds
   virtual bool createAndInitializeRegions() = 0;

// Publish and subscribe the object class attributes.
// Register an object instance of the class.
   virtual bool publishSubscribeAndRegisterObject() = 0;

// Publish and Subscribe to an interaction class
   virtual bool publishAndSubscribeInteraction() = 0;

// Send the default update with Region.  A less simple federate would have to
// specify which attributes need be updated.  This on merely passes in the
// position which is sent with Region as the object update.
   virtual void sendUpdate(int currentPosition ) = 0;

// Send Interactions with Region.  The following two interactions are meant to
// emulate a cuckoo clock with both an hourly chime, and a quarterly chime.

// Send the hourly interaction with Region. This is an interaction that in this
// example occurs for each hour that is passed on the clock that is not
// {12,3,6,9}.
   virtual void sendInteraction_hourly() = 0;

// Send the quarterly interaction with Region.  This is an interaction that in
// this example occurs for each hour that is passed on the clock that is in the
// following set {12,3,6,9}
   virtual void sendInteraction_quarterly() = 0;

// changeBounds sets the subscription of publication bounds of this federate.
   virtual void changeBounds(int lower, int upper, int UTCZone) = 0;

// Set the RTI's enable advisory switch
   virtual void setEnableScopeAdvisories(bool yesNo) = 0;

// Get scope advisory setting
   bool enableScopeAdvisories() const ;

// Perform the tick or evokeCallback method.
   virtual bool tick(double atMost=0.0f) = 0;

// Perform the tick or evokeCallback method.
   virtual bool tick(double atLeast, double atMost) = 0;

   // Simulation Methods

// Set federate as publisher (true) or subscriber (false)
   virtual void setIsPublisher(bool yesNo) = 0;

// Return true if this federate is publishing
   bool isPublisher() const ;

// Set the position (number of seconds)
   virtual void setPosition(int data) = 0;

// Get the position (number of seconds)
   virtual int position() = 0;

// Set the number of seconds to increment each cycle
   void setSizeToInc(int data);

// Get the number of seconds to increment each cycle
   int sizeToInc() const ;

// Get the zone used to send or listen
   int zone() const ;

   // Region Range Bound Methods

// Set the update range (number of seconds ahead of current position)
// This value should be at least large enough to have the next update fall
// within the range.
   void setSendRangeSize(int data);

// Get the update range (number of seconds ahead of current position)
   int sendRangeSize() const ;

// Get this listen upper bound
   int listenUpperBound() const ;

// Get this listen lower bound
   int listenLowerBound() const ;

// Get the send upper bound
   int sendUpperBound() const ;

// Get the send lower bound
   int sendLowerBound() const;


// Set the Fed File Name
virtual void setFedFileName(const wchar_t* newFedName) = 0;

// Set the Fed File Name with a std::string.
virtual void setFedFileName(const char* newFedName) = 0;

// Get the Fed File Name
virtual char* getFedFileName() const = 0;

   // Constants used in calculations
   static const unsigned int NUMSECONDSPERMINUTE;
   static const unsigned int NUMMINUTESPERHOUR;
   static const unsigned int NUMSECONDSPERHOUR;

   // 0 seconds is the minimum.
   static const unsigned int LOWESTSecondsInRegion;
   //60 seconds * 60 minutes * 360 degrees.
   static const unsigned int GREATESTSecondsInRegion;
   // 0 is the default UTC
   static const unsigned int LOWESTUTCInRegion;
   // For this example, the World has only 24 distinct Time Zones. (GREATESTUTCInRegion = 23)
   static const unsigned int GREATESTUTCInRegion;

   enum simpleAttributeHandleIndex
   {
      simplePositionIndex = 0,
      simpleMaxIndex
   };

protected:

   // Our upper bound is the number of seconds in a circle.
   // This is our default upper bound of interest extent in our region.
   int myListenUpperBound;

   // This is our default lower bound of interest extent in our region.
   int myListenLowerBound;

   // Is this instance the publisher.  The Simple DDM example has one federate
   // publishing and the other federate publishing no information,
   // simply subscribing.
   bool myIsPublisher;

   //******************************************//
   // The following are publisher specific data
   //******************************************//
   // This is our default upper area of interest extent in our region.
   int mySendUpperBound;
   // This is our default lower area of interest extent in our region.
   int mySendLowerBound;
   // This is the default time increment between ticks (seconds)
   int mySizeToInc;
   // This is the calculated range of the sender
   float mySendRangeSize;
   // This represents the current position of the executing federate.
   //  The valid range for this int is between
   //                     [positionLowerBound, positionUpperBound)
   int myCurrentposition;

   // The number of updates sent
   int myUpdateCount;

   int myUTCZone;

   //******************************************//
   // The following is subscriber specific data
   //******************************************//
   // This boolean enables the scope Advisory callback from the rti1516.
   // The scoping callback is issued when an object that is subscribed with
   // region changes visibility to the federate.  i.e. When the subscribed and
   // published region start to instersect and cease to intersect.
   bool myEnableScopeAdvisories;

   //initialized represents whether or not the QT process has Initialized,
   // After main launches a QT thread,
   //  main waits for QT to set initialized before proceeding
   bool myInitialized;
   // closed is a global representing whether the main loop has exited for any
   // reason including the user closing the dialog.
   // The main loop sets it prior to exiting and the QT thread
   // exits when it detects the main loop has closed.
   bool myClosed;

   bool myRegionValid;
   bool myMapsInitialized;

private:
   // Assignment Operator not implemented: Copy not allowed
   simpleDDMFederate &operator=(const simpleDDMFederate&);
};


inline void simpleDDMFederate::setSizeToInc(int data)
{
   mySizeToInc = data;
}
inline void simpleDDMFederate::setSendRangeSize(int data)
{
   if ( data < (int)(GREATESTSecondsInRegion - LOWESTSecondsInRegion) )
   {
      mySendRangeSize = (float)data;
   }
   else
   {
      mySendRangeSize = (float)(GREATESTSecondsInRegion - LOWESTSecondsInRegion);
   }
}

inline int simpleDDMFederate::listenUpperBound() const
{
   return myListenUpperBound;
}

inline int simpleDDMFederate::listenLowerBound() const
{
   return myListenLowerBound;
}

inline bool simpleDDMFederate::isPublisher() const
{
   return myIsPublisher;
}

inline int simpleDDMFederate::sendUpperBound() const
{
   return mySendUpperBound;
}

inline int simpleDDMFederate::sendLowerBound() const
{
   return mySendLowerBound;
}

inline int simpleDDMFederate::sizeToInc() const
{
   return mySizeToInc;
}

inline int simpleDDMFederate::sendRangeSize() const
{
   return (int)mySendRangeSize;
}

inline bool simpleDDMFederate::enableScopeAdvisories() const
{
   return myEnableScopeAdvisories;
}

inline int simpleDDMFederate::zone() const
{
   return myUTCZone;
}

#endif