simpleDDMSimple1516.h

Go to the documentation of this file.

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

#ifndef REGIONEXAMPLE1516_H_
#define REGIONEXAMPLE1516_H_

// A wrapper around the RTI Ambassador calls that incorporates
// Data Distribution Management (DDM).
// The typical calls are supported such as create/destroy, join/resign,
// publish/subscribe, register/delete object, update object, and send interaction.
// The DDM calls to create and maintain regions are also supported and regions
// are used with the other services where appropriate.

#include <wchar.h>
#include "simpleDDMFederate.h"
#include <string.h>

#include <RTI/RTI1516.h>
#include <RTI/RTIambassadorFactory.h>
#include "simpleDDMFedAmb1516.h"

// Map between strings and attribute handles
typedef std::map<std::wstring, rti1516::AttributeHandle>  DtAttrNameHandleMap;
// Map between strings and parameter handles
typedef std::map<std::wstring, rti1516::ParameterHandle>  DtParamNameHandleMap;


class simpleDDMFederate1516 : public simpleDDMFederate
{
public:

// Default Constructor
   simpleDDMFederate1516();

// Constructor
   simpleDDMFederate1516(simpleDDMFederate1516& data);

// Destructor
   virtual ~simpleDDMFederate1516();

// RTI Wrappers

// Initialize the RTI
   void initializeRTI();

// Create a federation execution
   bool createFedEx();

// Join a federation execution
   bool joinFedEx();

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

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

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

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

// 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.
   void sendUpdate(int currentPosition);

// 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}.
   void sendInteraction_hourly();

// 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}
   void sendInteraction_quarterly();

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

// Perform the tick or evokeCallback method.
   void tick(double atLeast, double atMost);

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

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

   // Simulation Methods

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

// Get the position (number of seconds)
   int  position();

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


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

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


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

   
protected:

// Map between strings and attribute handles
   DtAttrNameHandleMap myAttrNameHandleMap;

// Map between strings and parameter handles
   DtParamNameHandleMap myParamNameHandleMap;

// Construct an attribute handle value pair set with the
// values containing the attribute names
   rti1516::AttributeHandleValueMap myAttrValues;

// Data shared between federate and federate ambassador
   DtTalkAmbData theAmbData;

private:
   // Federate and Federation info
   std::wstring myFederationName;
   std::wstring myFederationFile;
   std::wstring myFederateType;

   // An interaction published at {1, 2, 4, 5, 7, 8, 10 , 11}
   std::wstring myHourlyInteraction;

   // An interaction published at {3,6,9,12}
   std::wstring myQuarterlyInteraction;

   // The interaction class name
   std::wstring myInterClassName;

   // The object class name
   std::wstring myClassName;

   // The attribute name
   std::wstring myAttrName;

   // The RTI Ambassador
   rti1516::RTIambassador* myRTIamb;

   // The Federate Ambassador
   MyFederateAmbassador* myFedAmb;

   // the Handle for the hourlyInteraction, (to be retrieved from rti1516).
   rti1516::ParameterHandle myHourlyHandle;

   // the Handle for the quarterlyInteraction, (to be retrieved from rti1516).
   rti1516::ParameterHandle myQuarterlyHandle;

   // The dimension handle Set.
   rti1516::DimensionHandleSet myDimHandleSet;

   // Construct a parameter handle value pair set with the
   // values containing the parameter names
   rti1516::ParameterHandleValueMap myParamValues;

   // The name of the seconds dimension as specified in your FED file.
   std::wstring mySecondsDimensionName;
   // seconds dimension handle
   rti1516::DimensionHandle mySecondsDim;

   // The name of the UTC dimension as specified in your FED file.
   std::wstring myUTCDimensionName;
   // UTC dimension handle
   rti1516::DimensionHandle myUTCDim;

   // The object class handle (to be retrieved from rti1516).
   rti1516::ObjectClassHandle myClassHandle;

   //The object instance handle ( to be retrieved from the rti).
   rti1516::ObjectInstanceHandle myObjectInstanceHandle;

   // The interaction class handle (to be retrieved from rti1516).
   rti1516::InteractionClassHandle myInterClassHandle;

   rti1516::AttributeHandleSetRegionHandleSetPairVector myRegionHandleSet;

   // Array of attributeHandles.
   rti1516::AttributeHandleSet myAttrHandles;

   // Region handle list
   rti1516::RegionHandleSet myRegions;

   // The listen region
   rti1516::RegionHandle myListenRegion;

   // The send region
   rti1516::RegionHandle mySendRegion;
};


inline void simpleDDMFederate1516::setIsPublisher(bool yesNo)
{
   myIsPublisher = yesNo;
   theAmbData.isPublisher = yesNo;
}

inline void simpleDDMFederate1516::setEnableScopeAdvisories(bool yesNo)
{
   myEnableScopeAdvisories = yesNo;
   theAmbData.enableScopeAdvisories = yesNo;
}

inline int simpleDDMFederate1516::position()
{
   if (!isPublisher())
      myCurrentposition = theAmbData.position;
   return myCurrentposition;
}

inline void simpleDDMFederate1516::setFedFileName(const wchar_t* newFedName)
{   
   myFederationFile = std::wstring(newFedName);
}

inline void simpleDDMFederate1516::setFedFileName(const char* newFedName)
{   
   myFederationFile = DtToWString(newFedName);
}

inline char* simpleDDMFederate1516::getFedFileName() const
{
   return strdup(DtToString(myFederationFile).c_str());
}

#endif