ballController13.h

Go to the documentation of this file.

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

#ifndef BallController13_H_
#define BallController13_H_

#include "ballData.h"
#include "ballController.h"
#include <RTI.hh>

class HlaBounceFederateAmbassador;
class ObjectParams13;

// Class that updates owned balls and processes updates on
// other balls for 1516 federates
class BallController13 : public BallController
{
public:

   BallController13(BallMap* data, DdmRegionMap* regionData);
   virtual ~BallController13();

   // Creates (if not already created) and joins the given federation.
   // Returns success indicator. federateName is not used in 1516.
   virtual bool createAndJoinFederation(const std::wstring& federation,
      const std::wstring& federateType,
      const std::wstring& federateName = std::wstring(),
      bool includeInterExt = false);

   // Resigns from and attempts to destroy the current federation.
   // Returns success indicator.
   virtual bool resignAndDestroyFederation();

   // Subscribes to the ball class and all its attributes. Must already have
   // created and joined the federation. Returns success indicator.
   virtual bool subscribe();

   // Unsubscribes to the ball class and all its attributes. Must already have
   // created and joined the federation. Returns success indicator.
   virtual bool unsubscribe();

   // Deletes the ball with the given ID
   virtual void deleteBall(const std::wstring id);

   // Attempts to acquire the ball with the given ID
   virtual void acquireBall(const std::wstring id);

   // Attempts to divest the owned ball with the given ID
   virtual void divestBall(const std::wstring id);

   // Adds a new DDM subscription region
   virtual bool subscribeWithRegion(int xLowerBound, int yLowerBound,
      int xUpperBound, int yUpperBound);

   // Unsubscribes from the current DDM regions. If resubscribeWithoutRegion is
   // set, automatically resubscribes without regions.
   virtual bool unsubscribeWithRegions(bool resubscribeWithoutRegion);

   // Unsubscribes from the current DDM regions, but does not delete the region
   // information. Needed when adding a new region extent. If
   // resubscribeWithoutRegion is set, automatically resubscribes without regions.
   virtual bool unsubscribeWithRegionsKeepRegionInfo(bool resubscribeWithoutRegion);

   // Process discovery of a new ball
   void ballDiscovered(ObjectParams13* objParams);

   // Process removal of another federate's ball
   void ballRemoved(RTI::ObjectHandle handle);

   // Process the movement of the ball into a visible area
   void ballVisible(RTI::ObjectHandle handle);

   // Process the movement of the ball out of a visible area
   void ballNotVisible(RTI::ObjectHandle handle);

   // Process update of an existing ball
   void ballUpdated(RTI::ObjectHandle handle,
      const RTI::AttributeHandleValuePairSet& attrVals);

   // Tries to release ownership of the requested object
   void releaseOwnership(RTI::ObjectHandle theObject,
      RTI::AttributeHandleSet const & attributes);

   // Takes control of the ball which the federate has successfully acquired
   // ownership of
   void ownershipAcquired(RTI::ObjectHandle theObject,
      RTI::AttributeHandleSet const & attributes);

   // Tries to assume ownership of the object being divested
   void assumeOwnership(RTI::ObjectHandle theObject,
      RTI::AttributeHandleSet const & attributes);

   // Discontinues updates for the ball which the federate has successfully
   // divested ownership of
   void ownershipDivested(RTI::ObjectHandle theObject,
      RTI::AttributeHandleSet const & attributes);

   // Sets the field dimensions
   virtual void setDimensions(int minX, int minY, int maxX, int maxY);

   // Returns the federate ID (based on the federate handle)
   virtual const std::wstring& federateId() const;

   // Returns the federate type
   virtual const std::wstring& federateType() const;

   // Returns the federate name
   virtual const std::wstring& federateName() const;

   // Returns the federation name
   virtual const std::wstring& federationName() const;

   // Returns false. Federate name is not supported in 1.3.
   virtual bool isFederateNameSupported() const;

   // Returns false. The interaction FOM module extension is not supported
   // in 1.3.
   virtual bool isInteractionExtensionSupported() const;

protected:

   // Sends updates on all owned balls to other federates in the federation
   virtual void sendUpdates();

   // Receives updates on balls from other federates in the federation
   virtual void receiveUpdates();

   // Request the RTI to create the a new ball
   virtual void requestNewBall(Ball* ball, const std::wstring name);

   // Loads the AttributeHandleValuePairSet with the data from the given ball
   void setAttributesForBall(RTI::AttributeHandleValuePairSet& attrVals,
      const Ball* ball);

   // Loads the Ball with the data from the given attributes
   void setBallFromAttributes(Ball* ball,
      const RTI::AttributeHandleValuePairSet& attrVals);

   // Subscribes to the default region
   void subscribeToDefaultRegion();

   // Unsubscribes from the default region. Based on input parameter, either
   // deletes the discovered balls or marks them as out of scope.
   void unsubscribeFromDefaultRegion(bool deleteDiscoveredBalls);

   // Deletes known balls. Can delete owned, not owned, or both.
   virtual void deleteKnownBalls(bool deleteOwned, bool deleteOthers);

   // Marks all balls this federate does not own as out of scope
   void markBallsOutOfScope();

   // Creates a publication region for the given ball and sets ball's object 
   // parameters with the new region handle.
   bool createPublicationRegion(Ball* ball);

   // Constructs a user supplied tag for the given ball object parameters.
   // Not really relevant to federate operations.
   std::string constructTag(const Ball* ball) const;

private:

   // No default constructor
   BallController13();

protected:

   BallMap myPendingBalls;

   RTI::RTIambassador* myRtiAmbassador;
   HlaBounceFederateAmbassador* myFederateAmbassador;

   RTI::FederateHandle myFederateHandle;
   std::wstring myFederateHandleString;
   std::wstring myFederateType;
   std::wstring myFederationName;

   bool myIsSubscribedToDefaultRegion;
   RTI::Region* mySubscriptionRegion;

   int myDdmXRangeConv;
   int myDdmYRangeConv;

   RTI::ObjectClassHandle myBallClass;
   RTI::AttributeHandle myColorAttr;
   RTI::AttributeHandle mySizeAttr;
   RTI::AttributeHandle myXAttr;
   RTI::AttributeHandle myYAttr;
   RTI::AttributeHandle mySpeedAttr;
   RTI::AttributeHandle myDirectionAttr;
   RTI::AttributeHandleSet* myAllBallAttrs;
   RTI::AttributeHandleValuePairSet* myAttrVals;
   RTI::AttributeHandle myPrivToDeleteAttr;
   RTI::SpaceHandle myXYSpace;
   RTI::DimensionHandle myXDim;
   RTI::DimensionHandle myYDim;

   static const std::string theFedFile;
   static const std::string theBallClassName;
   static const std::string theColorAttrName;
   static const std::string theSizeAttrName;
   static const std::string theXAttrName;
   static const std::string theYAttrName;
   static const std::string theSpeedAttrName;
   static const std::string theDirectionAttrName;
   static const std::string thePrivToDeleteAttrName;
   static const std::string theXYSpaceName;
   static const std::string theXDimName;
   static const std::string theYDimName;
};

#endif