interClassDesc.h

Go to the documentation of this file.

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

#pragma once

#if   DtHLA 

#include <vlutil/vlMachineTypes.h>
#include "rtiNamespace.h"
#include "rtiCompatibility.h"
#include "region.h"
#include <vlutil/vlString.h>
#include "userTagModifiers.h"
#include <set>

class DtExerciseConn;
class DtVrlRtiAmbassador;

class DT_DLL_VL DtInteractionRep;
class DT_DLL_VL DtInteractionWithEncDec;

class DT_DLL_VL DtInterClassDesc
{
public:

   DtInterClassDesc(const char* className, 
      DtInterClassDesc* base, RTI::InteractionClassHandle handle,
      DtExerciseConn* exConn);
    
   virtual ~DtInterClassDesc();

   virtual void addParam(const char* paramName);

   virtual RTI::InteractionClassHandle handle() const;

   virtual const char* name() const;

   virtual const DtInterClassDesc* baseClass() const;

   virtual DtInterClassDesc* baseClass();

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

   virtual int numParameters() const;

   virtual RTI::ParameterHandle parameterHandleByName(const char *paramName);

   virtual DtString parameterNameByHandle(const RTI::ParameterHandle& hand);

#if !DtHLA_1516
   virtual int minParamHandle() const;
   virtual int maxParamHandle() const;
#endif

#if DtHLA_1516
   virtual const RTI::ParameterHandleSet& paramHandleSet() const;
#else
   virtual const RTI::AttributeHandleSet& paramHandleSet() const;
#endif

#if DtHLA_1516
   virtual const RTI::ParameterHandleSet& ownParamHandles() const;
#else
   virtual const RTI::AttributeHandleSet& ownParamHandles() const;
#endif

   virtual void publish();

   virtual void unpublish();

   virtual void subscribe();
   
   virtual void subscribe(DtDDMRegionSP region);
   
   virtual void passiveSubscribe();

   virtual void unsubscribe();

   virtual void unsubscribe(DtDDMRegionSP region);

   virtual bool published() const;

   virtual bool subscribed() const;

   virtual DtInterClassDesc* firstSubscribed();

   virtual DtVrlRtiAmbassador* rtiAmb();

   virtual bool neededByFederation() const;

   virtual bool everPublished() const;

   virtual bool everSubscribed() const;

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

public:

   static void setMaxParameters(int num);
   static int maxParameters();

   static void setSubscriptionTimeDelay(double delay);


   virtual void enableUnknownParameters();

   typedef void (*DtParameterEncoder)
      (const DtInteractionWithEncDec& inter,
      RTI::ParameterHandleValuePairSet* avlist,
      RTI::ParameterHandle handle);

   typedef void (*DtParameterDecoder)(DtInteractionWithEncDec* inter,
      const RTI::ParameterHandleValuePairSet& pvlist,  int i);

   virtual void setUnknownParameterDecoder(
      DtParameterDecoder decoder);

   virtual void setUnknownParameterEncoder(
      DtParameterEncoder encoder);

   virtual DtParameterEncoder unknownParameterEncoder();

   virtual DtParameterDecoder unknownParameterDecoder();

protected:

   static void startIntersCb(RTI::InteractionClassHandle hand,
      void* usr);

   static void stopIntersCb(RTI::InteractionClassHandle hand,
      void* usr);

   virtual void processStartInters(RTI::InteractionClassHandle hand);

   virtual void processStopInters(RTI::InteractionClassHandle hand);

protected:

   DtInterClassDesc(const DtInterClassDesc& orig);

   DtInterClassDesc& operator=(const DtInterClassDesc& orig);

protected:

   DtString myName;
   RTI::InteractionClassHandle myHandle;
#if DtHLA_1516
   RTI::ParameterHandleSet* myParams;
   RTI::ParameterHandleSet* myOwnParams;
#else
   RTI::AttributeHandleSet* myParams;
   RTI::AttributeHandleSet* myOwnParams;
#endif
   DtInterClassDesc* myBase;
   DtExerciseConn* myExConn;
   bool myNeededFlag;
   bool myPublished;
   bool mySubscribed;
   bool myEverPublished;
   bool myEverSubscribed;
   RTI::ParameterHandle myMinParamHand;
   RTI::ParameterHandle myMaxParamHand;
   int myNumSubscribeRequests;
   DtInteractionTagModifierSP myTagModifier;
   std::set<DtDDMRegionSP> mySubscribedRegions;
   DtParameterEncoder myUnknownParameterEncoder;
   DtParameterDecoder myUnknownParameterDecoder;

protected:

   static int theMaxParams;
   static double theSubscriptionTimeDelay;
};

inline RTI::InteractionClassHandle DtInterClassDesc::handle() const
{
   return myHandle;
}

inline int DtInterClassDesc::numParameters() const
{
   return (int)myParams->size();
}
#if DtHLA_1516
inline const RTI::ParameterHandleSet& DtInterClassDesc::paramHandleSet() const
#else
inline const RTI::AttributeHandleSet& DtInterClassDesc::paramHandleSet() const
#endif
{
   return *myParams;
}

#if DtHLA_1516
inline const RTI::ParameterHandleSet& DtInterClassDesc::ownParamHandles() const
#else
inline const RTI::AttributeHandleSet& DtInterClassDesc::ownParamHandles() const
#endif
{
   return *myOwnParams;
}

inline int DtInterClassDesc::maxParameters()
{
   return theMaxParams;
}

inline void DtInterClassDesc::setMaxParameters(int num)
{
   theMaxParams = num;
}

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

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

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

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


#endif