fom.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 "exerciseConn.h"
#include <mtl/fedReader.h>
#include <vlutil/vlFedTarget.h>
#include <map>

class DT_DLL_VL DtInterClassDesc;
class DT_DLL_VL DtObjClassDesc;
class DT_DLL_VL DtRtiAmbassador;




typedef enum DtMergeFomStatus_enum
{
   DtMergeFomStatusFailedDTD,
   DtMergeFomStatusFailedSwitches,
   DtMergeFomStatusFailedScaffolding,
   DtMergeFomStatusFailedContent,
   DtMergeFomStatusFailedUpdateRates,
   DtMergeFomStatusFailedTransportTypes,
   DtMergeFomStatusFailedUserDefinedTags,  
   DtMergeFomStatusFailedTime,
   DtMergeFomStatusFailedObjectClass,
   DtMergeFomStatusFailedInteractionClass,
   DtMergeFomStatusFailedDimensions,
   DtMergeFomStatusAlreadyPresentSuccess,
   DtMergeFomStatusSuccess
} DtMergeFomStatus;


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 );

   virtual void addSpace(const char* name);

   virtual void addDimension(const char* SpaceName, const char* dimName);

   virtual void addDimension(const char* dimName, unsigned long upperBound,
      unsigned long defaultLowerBound, unsigned long defaultUpperBound,
      bool excluded);

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

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

   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);

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

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

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

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

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

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

#if !DtHLA_1516




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

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

   virtual DtVrlRtiAmbassador* rtiAmb() const;

   virtual void print() const;

#if !DtHLA_1516


   int minObjClassHandle() const;   
   int maxObjClassHandle() const;   
   int minInterClassHandle() const;
   int maxInterClassHandle() const;
#endif

   int numObjClasses() const;
   int numInterClasses() const;

protected:

   virtual DtMergeFomStatus mergeTarget( const DtFom& module );   

   virtual DtMergeFomStatus mergeObjectClasses( const DtFom& module );

   virtual DtMergeFomStatus mergeObjClassDesc(const DtObjClassDesc* desc);

   virtual DtMergeFomStatus mergeInteractionClasses( const DtFom& module );

   virtual DtMergeFomStatus mergeIntClassDesc(const DtInterClassDesc* desc);

   virtual DtMergeFomStatus mergeSpaces( const DtFom& module );

   virtual DtMergeFomStatus mergeUpdateRates( const DtFom& module );

   virtual DtMergeFomStatus mergeSwitches( const DtFom& module );

   virtual bool switchesSame( const DtFom& module ) const;

   virtual bool transportTypesSame(DtFom const& module ) const;

   virtual bool timeTypesSame( const DtFom& module ) const;

   virtual bool userDefinedTagsSame( const DtFom& module ) const;

   virtual bool updateRatesSame( const DtFom& module ) const;

   virtual bool knownTransportType(const DtString) const;

   virtual bool knownTime(const DtString) const;

   virtual void addTime(const DtString);

   virtual unsigned int numTimeTypes() const;

   virtual bool knownUserDefinedTag(const DtString ) const;


public:
   static void setFomCreator(DtFomCreator);

   static DtFom* create(DtExerciseConn* exConn);

protected:

   DtExerciseConn* myExConn;

   std::map<DtString, DtInterClassDesc*> myInterClassesByName;
   std::map<DtString, DtObjClassDesc*>   myObjClassesByName;

#if !DtHLA_1516
   std::map<int, DtInterClassDesc*> myInterClassesByHandle;
   std::map<int, DtObjClassDesc*>   myObjClassesByHandle;
#else
   std::map<std::wstring, DtInterClassDesc*> myInterClassesByHandle;
   std::map<std::wstring, DtObjClassDesc*>   myObjClassesByHandle;
#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> myTransportTypes;
   std::set<DtString> myUserDefinedTags;
   std::map<DtString, bool > mySwitches;
   std::set<DtString> myTimeTypes;

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

protected:
   static DtFomCreator  theCreatorFunction;

  
 
};


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

#endif