intClassInfo.h

Go to the documentation of this file.

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


#ifndef DtInteractionClassInfo_H_
#define DtInteractionClassInfo_H_

#include <rtiMsConfig.h>
#include "paramInfo.h"
#include "attrHandSet.h"

#include <internalTypes.h>
#include <bitMask.h>

#include <vlutil/vlFedTarget.h>
#include <vlutil/vlHashlist.h>
#include <vlutil/vlInetAddr.h>

class DtRtiSaveFile;
class DtParamInfo;
class DtInteractionMgr;
class DtInteractionRegionSet;
class DtInteractionClassPacket;


enum DtSubcribeInteractionType
{
   DtSubcribeInteractionNone = 0,
   DtSubcribeInteractionActive = 1,
   DtSubcribeInteractionPassive = 2
};

class DT_DLL_LRC DtInteractionClassInfo
{
public:
   typedef std::map<DtInteractionClassHandle, DtInteractionClassInfo*> DtInteractionClassByHandleMap;
   typedef std::map<MAKRti::DtString, DtInteractionClassInfo*> DtInteractionClassByNameMap;

public:

   DtInteractionClassInfo(const char* name, DtInteractionClassInfo* base,
      DtInteractionClassHandle handle, DtSharingType sharing,
      MAKRti::DtString semantics, MAKRti::DtTransportType transport,
      MAKRti::DtOrderType order );

   DtInteractionClassInfo(const DtInteractionClassInfo& orig);

   DtInteractionClassInfo& operator=(const DtInteractionClassInfo& orig);

   virtual ~DtInteractionClassInfo();


   virtual void setFomType(MAKRti::DtFomType type);
   virtual MAKRti::DtFomType fomType() const;

   virtual DtParamInfo* addParam(const char* paramName, const char* semantics, bool addSorted);

   virtual DtParamInfo*  mergeParam(const char* paramName, const char* semantics);

   virtual void addSubclass(DtInteractionClassInfo* sub);
   

   virtual DtDimensionHandleStdSet const & dimensions() const;
   virtual void setDimensions(DtDimensionHandleStdSet const & dimList);


   virtual void addDimension(DtDimensionHandle dimHandle);
   virtual void removeDimension(DtDimensionHandle dimHandle);

   virtual const char* name() const;


   virtual bool isName(const char* name) const;
   virtual bool isFullName(const char* name) const;


   virtual DtInteractionClassHandle handle() const;
   virtual void setHandle(DtInteractionClassHandle handleValue);


   virtual DtInteractionClassHandle discoveredHandle() const;
   virtual void setDiscoveredHandle(DtInteractionClassHandle handleValue);

   virtual DtInteractionClassInfo* baseClass() const;

   virtual void setBaseClass(DtInteractionClassInfo* base);


   virtual const DtInteractionClassByHandleMap& subclasses() const;
   virtual DtInteractionClassByHandleMap& subclasses();

   virtual int isOfClass(DtInteractionClassHandle handle) const;

   virtual bool isMom();

   virtual bool isRoot();

   virtual int numParameters() const;

   virtual DtParameterByHandleMap const& params() const;

   virtual DtParameterByHandleMap const& ownParams() const;

   virtual DtParameterHandleSet const& parameterHandles() const;


   virtual       DtParamInfo* paramByHandle(const  DtParameterHandle theHandle);
   virtual const DtParamInfo* paramByHandle(const  DtParameterHandle theHandle) const;


   virtual       DtParamInfo* paramByName(const char* theName);
   virtual const DtParamInfo* paramByName(const char* theName) const;

   virtual DtParameterHandle paramHandle(const char* theName);

   virtual char* paramName(DtParameterHandle theHandle);

   virtual void publish(DtInteractionMgr* interMgr);

   virtual void unpublish();

   virtual int published() const;

   virtual void subscribe(bool active);

   virtual void unsubscribe();
   
   virtual int subscribed() const;

   virtual void remoteSubscribe(DtFederateHandle fedHandle, DtInteractionMgr* interMgr);

   virtual void remotePassiveSubscribe(
      DtFederateHandle fedHandle, DtInteractionMgr* interMgr);
   
   virtual void remoteUnsubscribe(
      DtFederateHandle fedHandle, DtInteractionMgr* interMgr, bool forSmartForwarding);

   virtual bool remoteFederateIsSubscribed(DtFederateHandle fedHandle) const;

   virtual int numRemoteFederatesSubscribed() const;

   virtual const MAKRti::DtList& subscribedFederates() const;

   virtual bool relevant() const;


   virtual MAKRti::DtTransportType transport() const;
   virtual void setTransport(MAKRti::DtTransportType theTransport);


   DtSharingType sharing() const;
   void setSharing(const DtSharingType sharing );


   const char* semantics() const;
   void setSemantics(const MAKRti::DtString& semantics);


   virtual MAKRti::DtOrderType order() const;
   virtual void setOrder(MAKRti::DtOrderType theOrder);


   virtual void setSpaceHandle(DtSpaceHandle spaceHandleValue);
   virtual DtSpaceHandle spaceHandle() const;
   //2}

   virtual MAKRti::DtInetAddr destinationAddress() const;

   virtual MAKRti::DtInetAddr destinationDevice() const;

   virtual void setDestination(MAKRti::DtInetAddr addr, MAKRti::DtInetAddr devAddr, 
      bool inclusive, MAKRti::DtInetAddr oldAddr, MAKRti::DtInetAddr oldDevAddr);

   virtual int subscribedWithRegion() const;

   virtual DtBitMask getDestinations(bool includeBaseClass=true) const;

   virtual void forceDestinations(DtBitMask const& mask, MAKRti::DtTime delay);

   virtual void overrideDestinations(DtBitMask const& mask);

   virtual void clearDestinationOverride();

#ifdef DDM
   virtual int numRemoteFederatesSubscribedWithRegion() const;

   virtual void remoteSubscribe(DtFederateHandle fedHandle, DtHandle regionSetHandle, DtInteractionMgr* interMgr);


   virtual bool remoteFederateIsSubscribedWithRegion(DtFederateHandle fedHandle) const;
   virtual bool remoteFederateIsSubscribedWithRegion(DtFederateHandle fedHandle, DtHandle regionSetHandle) const;

   virtual void remoteUnsubscribeRegion(DtFederateHandle fedHandle, DtHandle regionSetHandle, DtInteractionMgr* interMgr);


   virtual DtInteractionRegionSet* subRegionSet();
   virtual const DtInteractionRegionSet* subRegionSet() const;

   virtual void setSubRegionSet(DtInteractionRegionSet* regSet);


   virtual DtInteractionRegionSet* pasRegionSet();
   virtual const DtInteractionRegionSet* pasRegionSet() const;

   virtual void setPasRegionSet(DtInteractionRegionSet* regSet);
#endif

#ifdef DtMOM


   virtual unsigned long sentTally(MAKRti::DtTransportType transport) const;
   virtual void incrementSentTally(MAKRti::DtTransportType transport);
   virtual void setSentTally(unsigned long value, MAKRti::DtTransportType transport);
   virtual unsigned long receiveTally(MAKRti::DtTransportType transport) const;
   virtual void incrementReceiveTally(MAKRti::DtTransportType transport);
   virtual void setReceiveTally(unsigned long value, MAKRti::DtTransportType transport);

   virtual void overrideRelevance();
#endif

   virtual bool save( DtRtiSaveFile& file );

   virtual bool restore(DtInteractionClassPacket* packet);

   virtual void print() const;


   virtual bool sameAncestry(const DtInteractionClassInfo*) const; 
   bool operator==( const DtInteractionClassInfo& other ) const;
   bool operator!=( const DtInteractionClassInfo& other ) const;

   virtual bool isScaffolding() const;

   virtual bool diffClass(const DtInteractionClassInfo& classInfo, DtParameterByHandleMap& diff) const;


   virtual bool isUnknown() const;

   virtual void setIsUnknown(bool unknown);

   virtual bool sameInteractionClass(const DtInteractionClassInfo& interInfo, DtParameterByHandleMap* collectParametersToMerge) const;

   virtual bool sameParameters(const DtParameterByHandleMap& paramHandles, DtParameterByHandleMap* collectParametersToMerge) const;

   virtual bool diffParameters(const DtInteractionClassInfo& classInfo, DtParameterByHandleMap& diff) const;

public:

   static const char* swapRootName(const char* name, MAKRti::DtFomType fomType, MAKRti::DtString& adjustedName);

protected:


   virtual void addRemoteSubscription(DtFederateHandle fedHandle);
   virtual void addRemotePassiveSubscription(DtFederateHandle fedHandle);
   virtual void deleteRemoteSubscription(DtFederateHandle fedHandle, bool isForSmartForwarding=false);

#ifdef DDM

   virtual void addRemoteSubscription(DtFederateHandle fedHandle, DtHandle regionSetHandle);
   virtual void deleteRemoteSubscription(DtFederateHandle fedHandle, DtHandle regionSetHandle);
#endif

   virtual void inheritMergedParameter(const DtParamInfo& param);

   virtual void updateRelevance(DtInteractionMgr* interMgr);

   virtual void reIndexParametersByName(DtParamInfo* paramInfo);

   virtual void nameUpdateCheck();

   virtual void emptyParameters();


   void updateAvailableParameterHandle(DtParameterHandle paramHandle);
   void updateAvailableParameterHandles(const DtParameterHandleStdSet& handles);

   void addInheritedParameters(const DtInteractionClassInfo& baseClass);

   void addInheritedParameter(const DtParamInfo& paramInfo);

   void addOwnParameter(DtParamInfo* paramInfo);


   void addUsedSubClassParameter(DtParameterHandle handle);
   void addUsedSubClassParameters(const DtParameterHandleStdSet& handles);

protected:

   MAKRti::DtString myName;
   DtInteractionClassHandle myHandle;
   DtInteractionClassHandle myDiscoveredHandle;
   DtSpaceHandle mySpaceHandle;
   DtDimensionHandleStdSet myDimensions;
   MAKRti::DtFomType myFomType;
   bool myIsMom;
   bool myIsRoot;
   DtSubcribeInteractionType mySubscribed;
   int myPublished;
   DtInteractionClassInfo* myBase;
   DtInteractionClassByHandleMap mySubclassByHandle;
   DtInteractionClassByNameMap mySubclassesByName;
   MAKRti::DtTransportType myTransport; 
   MAKRti::DtString mySemantics;
   DtSharingType mySharing;

   DtParameterHandle myAvailableParameterHandle;

#ifdef DtMOM
   bool myRelevantOverride;
   unsigned long myBestEffortSentTally;
   unsigned long myBestEffortReceiveTally;
   unsigned long myReliableSentTally;
   unsigned long myReliableReceiveTally;
#endif

   MAKRti::DtOrderType myOrder;
   
   DtParameterByHandleMap myParamsByHandle;
   DtParameterByHandleMap myOwnParamsByHandle;
   DtParameterByNameMap myParamsByName;
   DtParameterByNameMap myOwnParamsByName;
   DtParameterHandleStdSet myUsedParameterHandles;

   DtParameterHandleSet myParameterHandleSet;

   int myFirstParam;

   MAKRti::DtHashlist myRemoteSubscriptions;
   MAKRti::DtHashlist myRemotePassiveSubscriptions;  
   DtBitMask  myRemoteSubscriberMask;
   DtBitMask*  myForceDestinationsMask;
   DtBitMask*  myOverrideDestinationsMask;
   MAKRti::DtTime myForceDestinationsTime;
   bool  myRelevant;
   MAKRti::DtInetAddr myAddr;
   MAKRti::DtInetAddr myDevAddr;
   MAKRti::DtClock myClock;

#ifdef DDM
   MAKRti::DtHashlist myRemoteRegionSubscriptions;
   DtBitMask  myRemoteRegionSubscriberMask;
   DtBitMask  myCombinedSubscriptionMask;
   DtInteractionRegionSet* mySubRegSet;
   DtInteractionRegionSet* myPasRegSet;
#endif

   bool myIsUnknown;

private:
   static const unsigned int theMaxParams;
   
};

#endif