simpleDDMSimple13.h

Go to the documentation of this file.

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

#ifndef REGIONEXAMPLE13_H_
#define REGIONEXAMPLE13_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 "simpleDDMFederate.h"
#include <string.h>
#include "RTI.hh"
#include "simpleDDMFedAmb13.h"

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


class simpleDDMFederate13 : public simpleDDMFederate
{
public:

// Default Constructor
   simpleDDMFederate13();

// Constructor
   simpleDDMFederate13(simpleDDMFederate13& data);

// Destructor
   ~simpleDDMFederate13();

// 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 char* newFedName);

// Set the Fed File Name
void setFedFileName(const wchar_t* 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;

   static const unsigned int myNumAttributes;
   static const unsigned long myNumExtents;

   // Array of attributeHandles.
   RTI::AttributeHandle* myAttrHandlesArray;

   RTI::AttributeHandleSet* myAttrHandlesSet;

   RTI::AttributeHandleValuePairSet *myAttrValues;

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

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

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

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

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

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

   // The attribute name
   std::string myAttrName;

   // The number of dimensions
   unsigned int myNumberOfDimensions;

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

   // The Federate Ambassador
   MyFederateAmbassador* myFedAmb;

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

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


   // Construct a parameter handle value pair set with the
   // values containing the parameter names
   RTI::ParameterHandleValuePairSet* myParamValues;

   // The name of the dimension is specified in your FED file.
   std::string mySecondsDimensionName;

   // The time zone dimension name
   std::string myUTCDimensionName;

   // The routing space name
   std::string mySpaceName;

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

   //The object instance handle ( to be retrieved from the rti).
   RTI::ObjectHandle myObjectHandle;

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

   // The Seconds dimension handle (to be retrieved from the RTI).
   RTI::DimensionHandle mySecondsDimHandle;

   // The UTC dimension handle (to be retrieved from the RTI).
   RTI::DimensionHandle myUTCDimHandle;

   // The listen region
   RTI::Region* myListenRegion;

   // The publish region
   RTI::Region* mySendRegion;


};

inline void simpleDDMFederate13::setIsPublisher(bool yesNo)
{
   myIsPublisher = yesNo;
   myAmbData.isPublisher = yesNo;
}

inline void simpleDDMFederate13::setEnableScopeAdvisories(bool yesNo)
{
   myEnableScopeAdvisories = yesNo;
   myAmbData.enableScopeAdvisories = yesNo;
}

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

inline void simpleDDMFederate13::setFedFileName(const char* newFedName)
{
   myFederationFile = std::string(newFedName);
}

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

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



#endif