rtiObject.h

Go to the documentation of this file.

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

#ifndef rtiObject_H_
#define rtiObject_H_


#include "attrHandSet.h"
#include "aHandValBase.h"
#include <vlutil/vlUtil.h>
#include "requestDb.h"
#include <vlutil/vlHashlist.h>
#include <vlutil/vlFedTarget.h>
#include "pubRegSet.h"
#include "bitMask.h"
#include "internalTypes.h"
#include <deque>

class DtObjectClassInfo;
class DtPubRegionSet;
class DtFomClassMgr;
class DtAhvps;
class DtRtiObject;


class DT_DLL_LRC DtObjectAttrInfo
{
   friend class DtRtiObject;
   class tuple
   {
   public:
      tuple(){}
      tuple(unsigned int o, float r, MAKRti::DtTime t):offset(o),rate(r),timestamp(t){}
   public:
      unsigned int offset; 
      float rate;
      MAKRti::DtTime timestamp;
   };

public:
   DtObjectAttrInfo();

public:

   MAKRti::DtTransportType transport;

   MAKRti::DtOrderType order;

   DtHandle regionSetHandle;

   DtPubRegionSet* regionSet;

   DtRegionToFederateMap remoteSubscriptionRegions;

   DtFederateToRegionMap remoteSubscriptionRegionsByFederate;

   DtFederateHandleStdSet remoteSubscriptions;

   DtBitMask remoteSubscriberMask;

   MAKRti::DtTime myNextReceiveTime;

   std::deque<tuple> offsets;
};

enum DtUpdateType
{
   DtUpdateMomFederateObject,
   DtUpdateMomFederationObject,
   DtUpdateFederateObject
};

typedef DtRtiObject* (*DtEmptyRtiObjectCreator)();

typedef DtRtiObject* (*DtRegisteredRtiObjectCreator)(DtObjectInstanceHandle id,
                                                     const char* objName,
                                                     DtObjectClassInfo* actualClass,
                                                     DtUpdateType updateType);

typedef DtRtiObject* (*DtDiscoveredRtiObjectCreator)(DtObjectInstanceHandle id,
                                                     const char* objName,
                                                     DtObjectClassInfo* actualClass,
                                                     DtObjectClassInfo* discoveredClass,
                                                     DtUpdateType updateType);



class DT_DLL_LRC DtRtiObject
{
protected:   
   DtRtiObject();

   DtRtiObject(DtObjectInstanceHandle id, 
      const char* name,    
      DtObjectClassInfo* classDesc,
      DtUpdateType updateType=DtUpdateFederateObject);

   DtRtiObject(DtObjectInstanceHandle id, 
      const char* objName, 
      DtObjectClassInfo* actualClass,
      DtObjectClassInfo* discoveredClass,
      DtUpdateType updateType=DtUpdateFederateObject);

public:   
   virtual ~DtRtiObject();

   static DtRtiObject* createEmptyObject();

   static DtRtiObject* createRegisteredObject(DtObjectInstanceHandle id, 
                                       const char* name,    
                                       DtObjectClassInfo* classDesc,
                                       DtUpdateType updateType=DtUpdateFederateObject);

   static DtRtiObject* createDiscoveredObject(DtObjectInstanceHandle id, 
                                       const char* name,    
                                       DtObjectClassInfo* classDesc,
                                       DtObjectClassInfo* discoveredClass,
                                       DtUpdateType updateType=DtUpdateFederateObject);

   static void setEmptyCreatorFunction(DtEmptyRtiObjectCreator fn);

   static void setRegisteredCreatorFunction(DtRegisteredRtiObjectCreator fn);

   static void setDiscoveredCreatorFunction(DtDiscoveredRtiObjectCreator fn);
                                       

   DtRtiObject(const DtRtiObject& orig);

   const DtRtiObject& operator=(const DtRtiObject& orig);

   void initUpdateRates(const MAKRti::DtUpdateRateSetT rates);


   virtual void setObjHandle(DtObjectInstanceHandle handle);
   virtual DtObjectInstanceHandle objHandle() const;
   virtual DtObjectInstanceHandle id() const;

   virtual const char* objName() const;
   virtual void setObjName(const char* name);

   virtual DtObjectClassHandle actualClassHandle() const;

   virtual DtObjectClassHandle knownClassHandle() const;
 
   virtual void setKnownClass(DtObjectClassInfo* classInfo);

   virtual DtObjectClassInfo* knownClass();

   virtual DtObjectClassInfo* actualClass();

   virtual int owned(DtAttributeHandle handle) const;

   virtual bool ownPriviledgeToDelete();

   virtual DtFederateHandle ownerHandle() const;
   virtual void setOwnerHandle(DtFederateHandle handle);

   virtual void setIsKnown(bool isKnownValue);
   virtual bool isKnown() const;

   DtUpdateType updateType() const;

   virtual void setDiscoveredClass(DtFederateHandle remoteFedHandle,
      DtObjectClassInfo const& classInfo);

   virtual void removeDiscoveredClass(DtFederateHandle remoteFedHandle);

   virtual DtObjectClassHandle discoveredClass(
      DtFederateHandle remoteFedHandle);

   virtual bool isDiscovered(DtFederateHandle remoteFedHandle);

   virtual bool hasBeenUpdated() const;

   virtual void markAsUpdated();

   virtual bool hasBeenReflected() const;

   virtual void markAsReflected();

   virtual int rtiOwned(DtAttributeHandle handle) const;

   virtual int lrcManaged(DtAttributeHandle handle) const;
   
   virtual void takeFromLrc(const DtAttributeHandleSet& set);
   
   virtual void giveToLrc(const DtAttributeHandleSet& set);

   virtual void divestToLrc(const DtAttributeHandleSet& set);

   virtual void giveToRti(const DtAttributeHandleSet& set);

   virtual void lrcUnmanage(const DtAttributeHandleSet& set);



   virtual void addRequest(const DtAttributeHandleSet& requestSet,
      bool ifAvail);
   virtual void removeRequest(const DtAttributeHandleSet& set);


   virtual void addDivesting(const DtAttributeHandleSet& divestSet);
   virtual void removeDivesting(const DtAttributeHandleSet& set);

   virtual void addRemoteRequest(
      const DtAttributeHandleSet& requestSet,
      DtFederateHandle fed);

   virtual void removeRemoteRequest(
      const DtAttributeHandleSet& requestSet,
      DtFederateHandle fed);



   virtual void addPendingConfirm(const DtAttributeHandleSet& attrs,
      DtFederateHandle fed);
   virtual void removePendingConfirm(const DtAttributeHandleSet& requestSet,
      DtFederateHandle fed);
   virtual void removePendingConfirm(const DtAttributeHandleSet& set);


   virtual void addSkipPendingConfirm( const DtAttributeHandleSet& requestSet, DtFederateHandle fed);
   virtual void removeSkipPendingConfirm( const DtAttributeHandleSet& requestSet, DtFederateHandle fed);
   virtual DtFederateHandle pendingSkipConfirm( DtAttributeHandle hand) const;
   virtual DtAttributeHandleSet const& pendingSkipConfirmAttributes() const;
   virtual DtAttributeHandleSet pendingSkipConfirmByFed( DtFederateHandle fed) const;
   virtual void removePendingSkipConfirm(const DtAttributeHandleSet& set);




   virtual void cancelDivest(const DtAttributeHandleSet& set);

   virtual void cancelRemoteRequest(
      const DtAttributeHandleSet& requestSet,
      DtFederateHandle fed );

   virtual void cancelAllRemoteRequests( const DtAttributeHandleSet& requestSet );

   virtual void removeCanceledRequests(DtAttributeHandleSet const& requestSet);

   virtual DtAttributeHandleSet canceledRequestSet() const;

   virtual bool isRequestCanceled(DtAttributeHandle hand);

   virtual int requestCount() const;

   virtual DtAttributeHandleSet const& requestedAttributes() const;

   virtual int confirmCount() const;

   virtual DtAttributeHandleSet const& pendingConfirmAttributes() const;

   virtual DtFederateHandle pendingRemoteRequest(
      DtAttributeHandle hand);

   virtual DtFederateHandle pendingConfirm(DtAttributeHandle hand) const;

   virtual DtFederateHandle releaseRequested(
      const DtAttributeHandleSet& inSet,
      DtAttributeHandleSet* releasedSet,
      bool keepForConfirm);
   
   virtual DtFederateHandle releaseConfirm(
      const DtAttributeHandleSet& inSet, 
      DtAttributeHandleSet* releasedSet);

   virtual DtAttributeHandleSet requestedByFed(DtFederateHandle fed,
      bool includePendingConfirm=false);

   virtual DtAttributeHandleSet pendingConfirmByFed( DtFederateHandle fed  ) const;

   virtual DtFederateHandle unavailablePendingRequests( DtAttributeHandleSet* invalidatedSet );




   virtual bool pendingUncondRequest(DtAttributeHandle hand);
   virtual bool pendingRequestIfAvail(DtAttributeHandle hand);

   virtual void releaseAttrs(const DtAttributeHandleSet& releaseSet);

   virtual void takeAttrs(const DtAttributeHandleSet& takeSet);

   virtual bool okToReceive(DtHandle attrHandle, float tolerance);

   virtual unsigned int computeAttrOffset(DtHandle attrHandle);

   virtual const DtAttributeHandleSet& filterOwned(
      const DtAttributeHandleSet& inSet) const;

   virtual int expectedCount(
      const DtAhvps& inSet,
      DtHandle regSetHandle) const;

   virtual void selectExpected(
      DtAhvps& outSet,
      const DtAhvps& inSet,
      DtHandle regSetHandle) const;

   virtual void removeUnexpected(
      DtAhvps& attrSet,
      DtHandle regSetHandle) const;

   virtual int isOfActualClass(DtAttributeHandle handle) const;

   virtual int isOfKnownClass(DtAttributeHandle handle) const;

   virtual int expecting(DtAttributeHandle handle,
      DtHandle regSetHandle) const;

   virtual const DtAttributeHandleSet& lrcManagedAttrs();
   
   virtual const DtAttributeHandleSet& ownedAttrs();

   virtual const DtAttributeHandleSet& rtiOwnedAttrs();

   virtual const DtAttributeHandleSet& divestingAttrs();

   virtual const DtAttributeHandleSet& divestedAttrs();

   virtual const DtAttributeHandleSet& uncondRequestedAttrs();

   virtual const DtAttributeHandleSet& ifAvailRequestedAttrs();

   virtual int inScope(DtAttributeHandle handle) const;

   virtual const DtAttributeHandleSet& inScopeAttrs();

   virtual bool inScope() const;

   virtual void addToScope(DtAttributeHandle handle);

   virtual void addToScope(const DtAttributeHandleSet& attrs);

   virtual void removeFromScope(DtAttributeHandle handle);

   virtual void removeFromScope(const DtAttributeHandleSet& attrs);


   virtual void remoteSubscribe(DtFederateHandle fedHandle,
      const DtAttributeHandleSet& attrs);
   virtual void remoteSubscribe(DtFederateHandle fedHandle,
      DtAttributeHandle attributeHandle);


   virtual void remotePassiveSubscribe(DtFederateHandle fedHandle,
      DtAttributeHandle attrHandle);
   virtual void remotePassiveSubscribe(DtFederateHandle fedHandle,
      const DtAttributeHandleSet& attrs);


   virtual void remoteUnsubscribe(DtFederateHandle fedHandle,
      DtAttributeHandle attrHandle);
   virtual void remoteUnsubscribe(DtFederateHandle fedHandle,
      const DtAttributeHandleSet& attrs);
   virtual void remoteUnsubscribe(DtFederateHandle fedHandle);

   virtual void acquireRemoteSubscriptions(const DtAttributeHandleSet& attrs,
      DtFomClassMgr* fom);

#ifdef DDM


   virtual void remoteSubscribeRegion( DtFederateHandle fedHandle,
      DtHandle regionSetHandle,
      DtAttributeHandle handle );
   virtual void remoteSubscribeRegion( DtFederateHandle fedHandle,
      DtHandle regionSetHandle,
      const DtAttributeHandleSet& attrs );


   virtual void remoteUnsubscribeRegion( DtFederateHandle fedHandle,
      DtHandle regionSetHandle,
      DtAttributeHandle attrHandle );
   virtual void remoteUnsubscribeRegion( DtFederateHandle fedHandle,
      DtHandle regionSetHandle,
      const DtAttributeHandleSet& attrs );
   virtual void remoteUnsubscribeRegion( DtFederateHandle fedHandle,
      DtHandle regionSetHandle);

#endif


   virtual DtBitMask getDestinations() const;
   virtual DtBitMask getDestinations( const DtAttributeHandleSet& attrs ) const;
   virtual DtBitMask getDestinations( const DtAhvpBase& attrs ) const;

   virtual void getBaseClassDestinations(DtBitMask & dest, const DtAhvpBase& attrs, DtObjectClassInfo * baseClass ) const;

   virtual void overrideDestinations(DtBitMask const& mask);

   virtual void setAllDestinations();

   virtual void divestRemoteSubscriptions(const DtAttributeHandleSet& attrs);

   virtual bool isUpdateOn(DtAttributeHandle handle) const;

   virtual DtAttributeHandleSet updateOnAttrs() const;

   virtual DtAttributeHandleSet updateOffAttrs() const;

   virtual bool isUpdateOn() const;


   virtual void turnUpdateOn(DtAttributeHandle handle);
   virtual void turnUpdateOn(const DtAttributeHandleSet& attrs);


   virtual void turnUpdateOff(DtAttributeHandle handle);
   virtual void turnUpdateOff(const DtAttributeHandleSet& attrs);

   virtual MAKRti::DtTransportType attrTransport(
      DtAttributeHandle theHandle);
   
   virtual MAKRti::DtOrderType attrOrder(
      DtAttributeHandle theHandle);

   virtual void setAttrTransport(
      DtAttributeHandle theHandle, MAKRti::DtTransportType transport);
   
   virtual void setAttrOrder(
      DtAttributeHandle theHandle, MAKRti::DtOrderType order);

#ifdef DDM

   virtual void setRegionSet(DtAttributeHandle attrHandle,
      DtPubRegionSet* regionSet);
   virtual DtPubRegionSet* regionSet(DtAttributeHandle attrHandle);
#endif
   virtual DtHandle regionSetHandle(DtAttributeHandle attrHandle);

   virtual bool attrHasDimensions(DtAttributeHandle attrHandle) const;


   virtual unsigned int encodedLength() const;
   virtual void encode(const char *buff);

   virtual bool decode(const char *buff, DtFomClassMgr* fom);

   void setTimeToUseDestinations(MAKRti::DtTime timeVal);

   MAKRti::DtTime timeToUseDestinations() const;

   void addAttributeOwner(DtFederateHandle fedHandle, const DtAttributeHandleSet& attrs);

#ifdef DtIFSPEC1516E

    double getUpdateRate( DtAttributeHandle attrHandle ) const;
#endif

public:

   static void setUseDiscoveredClass(bool yesNo);

   virtual DtBitMask * getAttributeOwnerDestinationMask(DtBitMask * bitMask = NULL) const;

protected:

   inline DtRtiObject* self() const;

   virtual void addRemoteSubscribe(DtFederateHandle fedHandle,
      DtAttributeHandle attrHandle);

   virtual void removeRemoteSubscribe(DtFederateHandle fedHandle,
      DtAttributeHandle attrHandle);

protected:
   
   DtObjectInstanceHandle myId;

   DtObjectClassHandle myActualHandle;

   DtObjectClassHandle myKnownHandle;

   char* myObjName;

   DtAttributeHandleSet myOwnedSet;

   DtAttributeHandleSet myOutHandleSet;

   bool myIsKnown;

   DtFederateHandle myOwnerHandle;

   bool myHasBeenUpdated;

   bool myHasBeenReflected;

   DtUpdateType myUpdateType;

   DtAttributeHandleSet myLrcManagedSet;

   DtAttributeHandleSet myUnownedSet;

   DtAttributeHandleSet myDivestedSet;

   DtAttributeHandleSet myRtiOwnedSet;

   DtAttributeHandleSet myPendingRequestSet;
   DtAttributeHandleSet myPendingReqIfAvailSet;

   DtAttributeHandleSet myDivestingSet;

   DtRequestDatabase myRemoteReqDb;

   DtObjectClassInfo* myActualClass;

   DtObjectClassInfo* myKnownClass;

   DtAttributeHandleSet myInScopeAttrs;

   DtAttributeHandleSet myUpdateOnAttrs;

   MAKRti::DtHashlist myDiscoveredClass;

   DtBitMask*  myOverideDestinationsMask;

   DtObjectAttrInfo* myAttrs;

   unsigned myNumAttrs;

   MAKRti::DtTime myTimeToUseDestinations;

   std::map<DtAttributeHandle, DtFederateHandle> myKnownAttributeOwnersMap;

protected:
   static bool theUseDiscoveredClass;

   static DtEmptyRtiObjectCreator theEmptyCreator;
   static DtRegisteredRtiObjectCreator theRegisteredCreator;
   static DtDiscoveredRtiObjectCreator theDiscoveredCreator;

   std::map<float,DtObjectAttrInfo::tuple> myUpdateRateHold;
};

#endif