objClassDesc13.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/



#pragma once

#if DtHLA && !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 int isOfClass(RTI::ObjectClassHandle hand) const;

   virtual int numAttributes() const;

   virtual bool hasAttribute(const char* attrName) const;
   
   virtual int minAttrHandle() const;
   virtual int maxAttrHandle() 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(const RTI::AttributeHandleSet& hSet, bool active = true);
   
   virtual void subscribe(const RTI::AttributeHandleSet& hSet, DtDDMRegionSP region,
      bool active = true);

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

   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 setMaxAttributes(int num);
   static int maxAttributes();

   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 addAttr(const char* attrName, RTI::AttributeHandle attrHandle,
      bool isPrivilegeToDelete, bool withSpace = false);

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;
   std::vector<DtDDMRegionSP> mySubscribedRegions;
   DtHlaStateEncoder::DtAttributeEncoder myUnknownAttributeEncoder;
   DtHlaStateEncoder::DtAttributeCheckerWithHandle myUnknownAttributeChecker;
   DtHlaStateDecoder::DtAttributeDecoder myUnknownAttributeDecoder;
protected:
   static int theMaxAttrs;
   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 int DtObjClassDesc::maxAttributes()
{
   return theMaxAttrs;
}

inline void DtObjClassDesc::setMaxAttributes(int num)
{
   theMaxAttrs = num;
}

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

inline int DtObjClassDesc::numAttributes() const
{
   return 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 DtObjClassDesc* DtObjClassDesc::self() const
{
   return (DtObjClassDesc*) this;
}

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

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

#endif