objClassDesc1516.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/



#pragma once

#if DtHLA_1516 


#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlString.h>
#include "hlaStateEncoder.h"
#include "hlaStateDecoder.h"
#include "rtiNamespace.h"
#include "region.h"
#include "userTagModifiers.h"
#include <map>
#include <list>

class DtExerciseConn;
class DtVrlFederateAmbassador;
class DtVrlRtiAmbassador;

class DT_DLL_VL DtObjClassDesc
{
public:

   DtObjClassDesc(const char* className, 
      DtObjClassDesc* base, 
      RTI::ObjectClassHandle handle,
      DtExerciseConn* exConn);

   virtual ~DtObjClassDesc();

   virtual void addAttr(const char* attrName, bool withSpace = false);

   virtual RTI::ObjectClassHandle handle() const;

   virtual RTI::AttributeHandle attributeHandleByName(const char *attrName) const;

   virtual DtString attributeNameByHandle(const RTI::AttributeHandle& hand) const;

   virtual const char* name() const;

   virtual const DtObjClassDesc* baseClass() const;

   virtual DtObjClassDesc* baseClass();

   virtual void addChildClass(DtObjClassDesc* child);

   virtual bool isLeafClass() const;

   virtual int isOfClass(RTI::ObjectClassHandle hand) const;

   virtual int numAttributes() const;

   virtual bool hasAttribute(const char* attrName) const;
   
   virtual const RTI::AttributeHandleSet& attrHandleSet() const;

   virtual const RTI::AttributeHandleSet& ownAttrHandles() const;

   virtual bool classNeededByFederation();

   virtual void publish();
   virtual void publish(const RTI::AttributeHandleSet& hSet);

   virtual void unpublish();


   virtual void subscribe(std::wstring const& updateRateDesignator, bool active); 
   virtual void subscribe(const DtDDMRegionSet& region, 
      std::wstring const& updateRateDesignator, bool active); 
   virtual void subscribe(const RTI::AttributeHandleSet& hSet, 
      std::wstring const& updateRateDesignator, bool active);
   virtual void subscribe(const RTI::AttributeHandleSet& hSet, DtDDMRegionSP region,
      std::wstring const& updateRateDesignator, bool active);

   virtual void subscribe(std::wstring const& updateRateDesignator = L""); 
   virtual void subscribe(const DtDDMRegionSet& region, 
      std::wstring const& updateRateDesignator = L""); 
   virtual void subscribe(const RTI::AttributeHandleSet& hSet, 
      std::wstring const& updateRateDesignator = L"");
   virtual void subscribe(const RTI::AttributeHandleSet& hSet, DtDDMRegionSP region,
      std::wstring const& updateRateDesignator = L"");
   

   virtual void passiveSubscribe();

   virtual void unsubscribe();
   virtual void unsubscribe(const DtDDMRegionSet& regionSet);

   virtual void requestUpdates();
   virtual void requestUpdates(const DtDDMRegionSet& region);
   virtual void requestUpdates(const RTI::AttributeHandleSet& hSet);
   virtual void requestUpdates(const RTI::AttributeHandleSet& hSet, 
      DtDDMRegionSP region);

   virtual const RTI::AttributeHandleSet& publishedAttrs() const;
   
   virtual bool everPublished() const;

   virtual const RTI::AttributeHandleSet& subscribedAttrs() const;

   virtual const RTI::AttributeHandleSet& attributesWithSpace() const;
   virtual const RTI::AttributeHandleSet& attributesWithoutSpace() const;

   virtual const RTI::AttributeHandleSet& subscribedAttrsWithSpace() const;
   virtual const RTI::AttributeHandleSet& subscribedAttrsWithoutSpace() const;

   virtual DtObjClassDesc* firstSubscribed();

   virtual bool everSubscribed() const;

   virtual DtVrlRtiAmbassador* rtiAmb();

   virtual DtVrlFederateAmbassador* fedAmb();

   virtual RTI::AttributeHandle privilegeHandle() const;

   virtual void setUserTagModifier(DtObjectTagModifierSP modifier);
   virtual DtObjectTagModifierSP userTagModifier();


   virtual void setSubscribeToUnspecifiedAttributesFlag(bool subscribe);
   virtual bool subscribeToUnspecifiedAttributesFlag();


   virtual void enableUnknownAttributes();

   virtual void setUnknownAttributeEncoder(
      DtHlaStateEncoder::DtAttributeEncoder encoder);

   virtual void setUnknownAttributeChecker(
      DtHlaStateEncoder::DtAttributeCheckerWithHandle checker);

   virtual void setUnknownAttributeDecoder(
      DtHlaStateDecoder::DtAttributeDecoder decoder);

   virtual DtHlaStateEncoder::DtAttributeEncoder unknownAttributeEncoder();

   virtual DtHlaStateEncoder::DtAttributeCheckerWithHandle unknownAttributeChecker();

   virtual DtHlaStateDecoder::DtAttributeDecoder unknownAttributeDecoder();


public:
   static void setSubscriptionTimeDelay(double delay);

protected:

   static void startRegCb(RTI::ObjectClassHandle h,
      void* usr);

   static void stopRegCb(RTI::ObjectClassHandle h,
      void* usr);

protected:

   virtual void processStartReg(RTI::ObjectClassHandle h);

   virtual void processStopReg(RTI::ObjectClassHandle h);

   virtual DtObjClassDesc* self() const;

   virtual void synchSubscribedAttributes();

   virtual void fillInAttributeHandleSetRegionHandleSetPairVector(
      const RTI::AttributeHandleSet& hSet, DtDDMRegionSP region, 
      RTI::AttributeHandleSetRegionHandleSetPairVector& pairVector);

   virtual void addAttr(const char* attrName, RTI::AttributeHandle attrHandle,
      RTI::DimensionHandleSet& dimSet, bool isPrivilegeToDelete, bool withSpace = false);

   virtual bool isMomAttribute(const char * attrName);

protected:
   DtString myName;
   RTI::ObjectClassHandle myHandle;
   RTI::AttributeHandleSet* myAttrs;
   RTI::AttributeHandleSet* myOwnAttrs;
   RTI::AttributeHandleSet* mySubAttrs;
   RTI::AttributeHandleSet* myPubAttrs;

   RTI::AttributeHandleSet* myAttrsWithSpace;

   RTI::AttributeHandleSet* myAttrsWithoutSpace;

   RTI::AttributeHandleSet* mySubAttrsWithSpace;
   RTI::AttributeHandleSet* mySubAttrsWithoutSpace;

   bool myClassNeeded;
   DtObjClassDesc* myBase;
   std::list<DtObjClassDesc*> myChildren;
   DtExerciseConn* myExConn;
   bool myPublished;
   bool myEverPublished;
   bool myEverSubscribed;
   int myNumSubscribeRequests;
   bool mySubscribeToUnspecifiedAttributesFlag;

   RTI::AttributeHandle myPrivHandle;
   RTI::AttributeHandle myMinAttrHand;
   RTI::AttributeHandle myMaxAttrHand;

   typedef std::map<RTI::AttributeHandle, DtString> StringToAttributeHandleMap;
   StringToAttributeHandleMap myStringToHandleMap;

   DtObjectTagModifierSP myTagModifier;

   typedef std::vector<RTI::AttributeHandleSetRegionHandleSetPair> 
      RegionHandleVector;
   RegionHandleVector mySubscribedRegions;

   DtHlaStateEncoder::DtAttributeEncoder myUnknownAttributeEncoder;
   DtHlaStateEncoder::DtAttributeCheckerWithHandle myUnknownAttributeChecker;
   DtHlaStateDecoder::DtAttributeDecoder myUnknownAttributeDecoder;

protected:

   static double theSubscriptionTimeDelay;
};

inline RTI::ObjectClassHandle DtObjClassDesc::handle() const
{ 
   return myHandle; 
}

inline const RTI::AttributeHandleSet& DtObjClassDesc::attrHandleSet() const
{
   return *myAttrs;
}

inline const RTI::AttributeHandleSet& DtObjClassDesc::ownAttrHandles() const
{
   return *myOwnAttrs;
}

inline const char* DtObjClassDesc::name() const
{
   return myName.c_str();
}

inline int DtObjClassDesc::numAttributes() const
{
   return (int)myAttrs->size();
}

inline const DtObjClassDesc* DtObjClassDesc::baseClass() const
{
   return myBase;
}

inline DtObjClassDesc* DtObjClassDesc::baseClass()
{
   return myBase;
}

inline void DtObjClassDesc::addChildClass(DtObjClassDesc* child)
{
   myChildren.push_back(child);
}

inline bool DtObjClassDesc::isLeafClass() const
{
   return myChildren.size() == 0;
}

inline DtObjClassDesc* DtObjClassDesc::self() const
{
   return (DtObjClassDesc*) this;
}

inline RTI::AttributeHandle DtObjClassDesc::privilegeHandle() const
{
   return myPrivHandle;
}

inline void DtObjClassDesc::setSubscriptionTimeDelay(double delay)
{
   theSubscriptionTimeDelay = delay;
}

#endif