simpleDDMSimple1516e.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 REGIONEXAMPLE1516E_H_
#define REGIONEXAMPLE1515E_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.
#ifdef DtHLA1516E
#include <wchar.h>
#include "simpleDDMFederate.h"
#include <string.h>

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

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


class simpleDDMFederate1516e : public simpleDDMFederate
{
public:

    // Default Constructor
    simpleDDMFederate1516e();

    // Constructor
    simpleDDMFederate1516e(simpleDDMFederate1516e& data);

    // Destructor
    virtual ~simpleDDMFederate1516e();

    // RTI Wrappers

    // Initialize the RTI
    void initializeRTI();

    // Connect
    void connect(RTIambassador & rtiAmb, MyFederateAmbassador & fedAmb);

    // 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
    rti1516e::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
    rti1516e::RTIambassador* myRTIamb;

    // The Federate Ambassador
    MyFederateAmbassador* myFedAmb;

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

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

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

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

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

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

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

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

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

    rti1516e::AttributeHandleSetRegionHandleSetPairVector myRegionHandleSet;

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

    // Region handle list
    rti1516e::RegionHandleSet myRegions;

    // The listen region
    rti1516e::RegionHandle myListenRegion;

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


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

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

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

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

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

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

#endif
#endif