reflectedExtEntityList.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2003 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: refExtEntList.h,v $ $Revision: 1.25 $ $State: Exp $
*******************************************************************************/

#ifndef REFEXTENTLIST_H
#define REFEXTENTLIST_H

#include <vl/reflectedEntityList.h>

#include <vrfExtObjects/reflectedExtEntity.h>
#include <vl/dataInteraction.h>
#include <vlutil/vlHashlist.h>

// class DtReflectedExtEntityList:
//
// Instances of DtReflectedExtEntityList manage the list of 
// remote entities in the exercise.

#include <vrfExtObjects/vrfExtObjectsDefines.h>
class DT_DLL_vrfExtObjects DtReflectedExtEntityList : public DtReflectedEntityList
{

public:

   // Constructor - obtains the set of object classes to subscribe
   // to from the exConn's fomMapper.
   DtReflectedExtEntityList(DtExerciseConn* exConn);

#if DtHLA


   DtReflectedExtEntityList(DtExerciseConn* exConn,
      const DtDDMRegionSet* regionSetToUse);

   DtReflectedExtEntityList(DtExerciseConn* exConn,
      const DtList *handleList, const DtDDMRegionSet* regionSetToUse = 0);

#endif
   
   // destructor
   virtual ~DtReflectedExtEntityList();

#if DtHLA
   #if DtHLA_1516
      virtual DtReflectedExtEntity* lookupEE ( RTI::ObjectInstanceHandle id);
   #else
      virtual DtReflectedExtEntity* lookupEE ( RTI::ObjectHandle id);
   #endif

   // Look up entity by name.
   virtual DtReflectedExtEntity* lookupEE (
                   const DtGlobalObjectDesignator& objName);
#elif (DtDIS || DtTENA)
   // Look up entity by identifier.
   virtual DtReflectedExtEntity* lookup(const DtObjectId& id);
#endif

   // Get the first/last entity in the list.
   virtual DtReflectedExtEntity* firstEE() const;
   virtual DtReflectedExtEntity* lastEE() const;

   // Entity added callback registration/deregistration.
   virtual void addEntityAdditionCallback (
      DtExtEntityCallbackFunction cb, void* userData);

   virtual void removeEntityAdditionCallback (
      DtExtEntityCallbackFunction cb, void* userData);

   // Entity removed callback registration/deregistration.
   virtual void addEntityRemovalCallback (
      DtExtEntityCallbackFunction cb, void* userData);

   virtual void removeEntityRemovalCallback (
      DtExtEntityCallbackFunction cb, void* userData);

   static void setTimeoutRequestTime(DtTime t);
   static DtTime timeoutRequestTime();

protected:

   void processVrfObjectStateUpdateMessage(DtDataInteraction* interaction);
   void processVrfObjectDataMessage(DtDataInteraction* interaction);

   static void dataInteractionCallback(DtDataInteraction* i, void* usr);

   virtual void processDataInteraction(DtDataInteraction* i);

#if DtHLA
   virtual DtReflectedObject* newReflectedObject(DtHlaObject* obj) const;
   virtual void addToObjectList(DtReflectedObject* refObj);
#elif DtDIS
   // Create a new reflected entity
   virtual DtReflectedEntity* newReflectedEntity (
      const DtEntityIdentifier& id, const DtEntityType& type) const;
   virtual void processRelativeLocationPdu(
      const DtRelativeLocationPdu& pdu);
#elif DtTENA
   // Create a new reflected entity
   virtual DtReflectedEntity* newReflectedEntity (
      const DtEntityIdentifier& id, const DtEntityType& type) const;
#else
#  pragma message ( "No protocol defined." )
#endif

   // Called from destructor, cleans up myObjectDataMessageHashlist and removed all memory
   virtual void cleanupObjectDataMessageHashList();

   // Overridden to check object data message hash list to see if there is a match
   virtual void objectAdded(DtReflectedObject* object);

#if !DtTENA
   // Overidden to see if:
   // a) This object is a VRF object
   // b) This object, if a VRF object, has a VRF object data message assigned (or waiting to be assigned)
   // If a) is true and b) is false, then, the object will not be added to the refleced list.  Instead, a request
   // will be sent out for the vrf object data associated with the object.  Once it is received, the object will
   // be added to the reflected list
   virtual bool readyToAdd(DtReflectedObject* obj);
#endif

   // Sets up extended state repository from cached vrf data (if exists).  If this method returns true, the object
   // was either not an extended object or it had the data correctly set
   virtual bool setupVrfObjectData(DtReflectedObject* object);

#if !DtTENA
   // Will start the process of adding an object to the reflected list if this object is waiting for a VRF message.
   // Returns true if this object is and was added to the list
   virtual bool addObjectIfWaitingForVrfMessage(DtReflectedExtEntity*);
#endif

   // This routine will request the vrf object data message to be sent for a VRF entity.  This request will be handled
   // by the entity publisher.
   virtual void requestVrfObjectData(DtReflectedObject* object);

   virtual bool timeOutVrfObjectDataRequest(DtReflectedObject* obj);

#if !DtTENA

   virtual void removeAndDelete(DtReflectedObject* obj,
      char* msg = NULL);
#endif

protected:

#if DtDIS

   virtual void processObjectAdditionCallbacks(DtReflectedObject* object);
#endif

private:
   // not implemented
   DtReflectedExtEntityList ( const DtReflectedExtEntityList& orig);
   DtReflectedExtEntityList& operator= ( const DtReflectedExtEntityList& rhs);

protected:
   // List to keep the vrfobject data messages that have been found but not associated with new entities yet
   DtHashlist myObjectDataMessageHashlist;

   // List to keep track of requests for vrf object message data and the time they were sent
   DtHashList myObjectDataMessageRequestList;

#if DtDIS
   // Reflected objects that are waiting for vrf object updates
   DtHashList myWaitingForVrfObjectData;
#elif DtHLA
   DtObjectIdHashList myWaitingForVrfObjectData;
#endif

   static DtTime theTimeoutRequestTime;
};

#endif   // REFEXTENTLIST_H