fom.h

Go to the documentation of this file.

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

#pragma once


#if DtHLA 


#include <vlutil/vlMachineTypes.h>
#include "rtiNamespace.h"
#include "exerciseConn.h"
#include <mtl/fedReader.h>
#include <vlutil/vlFedTarget.h>
#include <map>

class DT_DLL_VL DtRoutingSpaceDesc;
class DT_DLL_VL DtDimensionDesc;
class DT_DLL_VL DtInterClassDesc;
class DT_DLL_VL DtObjClassDesc;
class DT_DLL_VL DtRtiAmbassador;



class DT_DLL_VL DtFom;
typedef DtFom* (*DtFomCreator)(DtExerciseConn*);
class DT_DLL_VL DtFom : public DtFedTarget
{
public:


   DtFom(DtExerciseConn* exConn);

   virtual ~DtFom();

   DtFom(const DtFom& orig);

   DtFom& operator=(const DtFom& orig);

   virtual DtFedReadStatus readFed(const DtString& fedFile, 
      const std::vector<std::wstring>& fomModules, const DtString& mimModule,
      bool strictCheckingEnabled, bool useDTD, bool dontParseSwitches );

#if DtHLA_1516
   virtual void addDimension(const char* dimName, unsigned long upperBound,
      unsigned long defaultLowerBound, unsigned long defaultUpperBound,
      bool excluded, const DtString& normalization);
#else
   virtual void addSpace(const char* name);

   virtual void addDimension(const char* spaceName, const char* dimName);
#endif

   virtual bool addInterClass(const char* name, 
      const char* baseName, DtTransportType transport, 
      DtOrderType order, const char* space=NULL);
   
   virtual bool shouldPrintMissingClass(const char * name);

   virtual bool addObjClass(const char* name, 
      const char* baseName);

   virtual bool addObjectDimension(const char* objectClassName, const char* dimension);

   virtual void addParameter(const char* className, 
      const char* paramName);

   virtual bool addInteractionDimension(const char* interactionName,
      const char* dimension);

   virtual void addAttribute(const char* className, 
      const char* attrName, DtTransportType transport, 
      DtOrderType order, const char* space=NULL);

   void addAttribute( const char* className,
      const char* attrName, 
      DtTransportType transport, 
      DtOrderType order, 
      DtSharingType sharing, 
      DtFomUpdateType updateType, 
      const DtString& updateCondition, 
      DtOwnershipType ownershipType, 
      const DtString& semantics, const char* spaceName=NULL);

   virtual bool addAttributeDimension(const char* className,
      const char* attrName, const char* dimName);

#if DtHLA_1516
   virtual DtDimensionDesc* dimensionByName(const char* dimensionName) const;

   virtual DtDimensionDesc* dimensionByHandle( RTI::DimensionHandle dimensionHandle) const;
#else
   virtual DtRoutingSpaceDesc* spaceByName(const char *name) const;

   virtual DtRoutingSpaceDesc* spaceByHandle(RTI::SpaceHandle handle) const;

   virtual RTI::DimensionHandle dimensionHandle(const char* spaceName, const char* dimensionName) const;

   virtual const DtString& dimensionName(const char* spaceName, RTI::DimensionHandle dimHandle) const;
#endif

   virtual DtObjClassDesc* rootObjClass() const;

   virtual DtObjClassDesc* rootMomObjClass() const;

   virtual DtObjClassDesc* objClassByName(const char *name) const;

   virtual DtObjClassDesc* objClassByHandle(RTI::ObjectClassHandle handle) const;

   virtual const std::list<DtObjClassDesc*>& objClassList() const;

   int numObjClasses() const;

#if !DtHLA_1516
   int minObjClassHandle() const;
   int maxObjClassHandle() const;

   virtual DtObjClassDesc* firstObjClass() const;
   virtual DtObjClassDesc* lastObjClass() const;
   virtual DtObjClassDesc* nextObjClass(DtObjClassDesc* current) const;
#endif

   virtual DtInterClassDesc* rootInterClass() const;

   virtual DtInterClassDesc* rootMomInterClass() const;

   virtual DtInterClassDesc* interClassByName(const char *name) const;

   virtual DtInterClassDesc* interClassByHandle(RTI::InteractionClassHandle handle) const;

   virtual const std::list<DtInterClassDesc*>& interClassList() const;

   int numInterClasses() const;

#if !DtHLA_1516
   int minInterClassHandle() const;
   int maxInterClassHandle() const;
#endif


#if !DtHLA_1516
   virtual DtInterClassDesc* firstInterClass() const;
   virtual DtInterClassDesc* lastInterClass() const;
   virtual DtInterClassDesc* nextInterClass(DtInterClassDesc* current) const;
#endif

   virtual DtVrlRtiAmbassador* rtiAmb() const;

   virtual void print() const;

   //{@
   bool isDdmDisabled() const;
   void setIsDdmDisabled(bool val);

   bool isMomIsDisabled() const;
   void setIsMomIsDisabled(bool val);

protected: 

   virtual DtMergeFomStatus mergeObjectClasses( const DtFom& module );

   virtual DtMergeFomStatus mergeObjClassDesc(const DtObjClassDesc* desc);

   virtual DtMergeFomStatus mergeInteractionClasses( const DtFom& module );

   virtual DtMergeFomStatus mergeIntClassDesc(const DtInterClassDesc* desc);

 
public:
   static void setFomCreator(DtFomCreator);

   static DtFom* create(DtExerciseConn* exConn);



   static void setIntersection(const RTI::AttributeHandleSet& set1, const RTI::AttributeHandleSet& set2,
      RTI::AttributeHandleSet& destinationSet);

   static void setUnion(const RTI::AttributeHandleSet& set1, const RTI::AttributeHandleSet& set2,
      RTI::AttributeHandleSet& destinationSet);

   static void setDifference(const RTI::AttributeHandleSet& set1, const RTI::AttributeHandleSet& set2,
      RTI::AttributeHandleSet& destinationSet);

   static void setSymmetricDifference(const RTI::AttributeHandleSet& set1, const RTI::AttributeHandleSet& set2,
      RTI::AttributeHandleSet& destinationSet);

   static bool setsEqual(const RTI::AttributeHandleSet& set1, const RTI::AttributeHandleSet& set2);

   static void setInsert(RTI::AttributeHandleSet& handleSet, const RTI::AttributeHandle& handle);

   static void setInsert(RTI::AttributeHandleSet& destinationSet, const RTI::AttributeHandleSet& sourceSet);

   static void setRemove(RTI::AttributeHandleSet& handleSet, const RTI::AttributeHandle& handle);

   static void setRemove(RTI::AttributeHandleSet& destinationSet, const RTI::AttributeHandleSet& sourceSet);

   static void setClear(RTI::AttributeHandleSet& handleSet);


protected:

   DtExerciseConn* myExConn;

#if DtHLA_1516
   std::map<DtString, DtDimensionDesc*> myDimensionsByName;
#else
   std::map<DtString, DtRoutingSpaceDesc*> myRoutingSpacesByName;
#endif
   std::map<DtString, DtInterClassDesc*> myInterClassesByName;
   std::map<DtString, DtObjClassDesc*>   myObjClassesByName;

#if DtHLA_1516
   std::map<std::wstring, DtDimensionDesc*> myDimensionsByHandle;
   std::map<std::wstring, DtInterClassDesc*> myInterClassesByHandle;
   std::map<std::wstring, DtObjClassDesc*>   myObjClassesByHandle;
#else
   std::map<RTI::SpaceHandle, DtRoutingSpaceDesc*> myRoutingSpacesByHandle;
   std::map<int, DtInterClassDesc*> myInterClassesByHandle;
   std::map<int, DtObjClassDesc*>   myObjClassesByHandle;
#endif

#if DtHLA_1516
   std::list<DtDimensionDesc*> myDimensionList;
#else
   std::list<DtRoutingSpaceDesc*> myRoutingSpaceList;
#endif
   std::list<DtObjClassDesc*> myObjClassList;
   std::list<DtInterClassDesc*> myInterClassList;

#if !DtHLA_1516
   int myLowestObj;   
   int myHighestObj;   
   int myLowestInter;
   int myHighestInter;
#endif

   DtString myObjRootName;
   DtString myInterRootName;

   std::set<DtString> myFailedObjClasses;
   std::set<DtString> myFailedInterClasses;

   bool myDdmIsDisabled;
   bool myMomIsDisabled;
protected:
   static DtFomCreator  theCreatorFunction;

protected:

   virtual DtMergeFomStatus mergeObjectClasses( const DtFedTarget& module );

   virtual DtMergeFomStatus mergeInteractionClasses( const DtFedTarget& module );
 
   virtual bool resolveAttributeDimensions();
};


inline DtVrlRtiAmbassador* DtFom::rtiAmb() const
{
   return myExConn->rtiAmb();
}

#endif