vlFedTarget.h

Go to the documentation of this file.

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

#include <map>
#include <set>
#include <vector>
#include <cmath>

#include "vlutil/vlMachineTypes.h"
#include "vlutil/vlString.h"
#include "vlutil/vlUtil.h"
#include "vlutil/vlSmartPointers.h"
#include "vlutil/vlFedTargetTypes.h"

#include <mtl/fedTargetHelper.h>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

   typedef  std::set<std::shared_ptr<DtUpdateRateType>, FomTypeCompare<DtUpdateRateType> > DtUpdateRateSetT;

   typedef std::set<DtString> DtNameSet;
   typedef std::pair<DtString, DtString> DtNamePair;
   typedef std::set<DtNamePair> DtNamePairSet;
   typedef std::map<DtString, DtNamePairSet> DtNameToNamePairSetMap;
   typedef std::map<DtString, DtNameSet> DtNameToNameSetMap;
   typedef std::pair<DtString, DtNamePair> DtNameWithNamePair;
   typedef std::set<DtNameWithNamePair> DtNameWithNamePair_Set;
   typedef std::map< DtString, bool > DtSwitchesMap;

   typedef std::vector<DtString> DtNameVector;

   enum DtFomType
   {
      DtFomInvalid = 0,
      DtFom13 = 1,
      DtFom1516 = 2,
      DtFom1516E = 3,
      DtFom1516_4 = 4
   };

   enum DtMergeFomTableMask
   {
      DtMergeFomTableUnknown                = 0X00000000, // 0
      DtMergeFomTableIdentification         = 0X00000001, // 1
      DtMergeFomTableObjectClass            = 0X00000002, // 2
      DtMergeFomTableInteractionClass       = 0X00000004, // 4
      DtMergeFomTableDirectedInteraction    = 0X00000008, // 8
      DtMergeFomTableDimensions             = 0X00000010, // 16
      DtMergeFomTableTime                   = 0X00000020, // 32
      DtMergeFomTableUserDefinedTags        = 0X00000040, // 64
      DtMergeFomTableSyncPoints             = 0X00000080, // 128
      DtMergeFomTableTransportTypes         = 0X00000100, // 256
      DtMergeFomTableUpdateRates            = 0X00000200, // 512
      DtMergeFomTableSwitches               = 0X00000400, // 1024
      DtMergeFomTableBasicDataRepType       = 0X00000800, // 2048
      DtMergeFomTableSimpleDataType         = 0X00001000, // 4096
      DtMergeFomTableEnumeratedDataType     = 0X00002000, // 8192
      DtMergeFomTableArrayDataType          = 0X00004000, // 16384
      DtMergeFomTableFixedRecordDataType    = 0X00008000, // 32768
      DtMergeFomTableVariantRecordDataType  = 0X00010000, // 65536
      DtMergeFomTableReferenceType          = 0X00020000, // 131072
      DtMergeFomTableNotes                  = 0X00040000, // 262144
   };

   #define DEFAULT_MERGE_MASK DtMergeFomTableObjectClass | DtMergeFomTableInteractionClass \
         | DtMergeFomTableDimensions | DtMergeFomTableTime | DtMergeFomTableUserDefinedTags | DtMergeFomTableSyncPoints \
         | DtMergeFomTableTransportTypes | DtMergeFomTableUpdateRates | DtMergeFomTableSwitches | DtMergeFomTableBasicDataRepType \
         | DtMergeFomTableSimpleDataType | DtMergeFomTableEnumeratedDataType | DtMergeFomTableArrayDataType \
         | DtMergeFomTableFixedRecordDataType | DtMergeFomTableVariantRecordDataType
      //| DtMergeFomTableNotes (removed from defaults to hide merge issues in VRL 5.9.1 FOMs)
      //| DtMergeFomTableReferenceType | DtMergeFomTableDirectedInteraction (not implemented yet)


   enum DtTransportType
   {
      DtTransportUnknown=-1,
      DtBest_Effort,
      DtReliable
   };

   enum DtOrderType
   {
      DtUnknownOrder=-1,
      DtReceive,
      DtTimestamp
   };

   enum DtReliableType
   { 
      DtReliableUnknown=-1,
      Yes,
      No
   };

   enum DtResignAction
   {
      DtUnconditionallyDivestAttributes,
      DtDeleteObjects,
      DtCancelPendingOwnershipAcquitions,
      DtDeleteObjectsThanDivest,
      DtCancelThenDeleteThenDivest,
      DtNoAction
   };

   typedef void (*fptr)(void *);


   class DT_DLL_VLUTIL DtFedTarget
   {
   public:

      DtFedTarget();

      virtual ~DtFedTarget();

      DtFedTarget(const DtFedTarget& orig);

      DtFedTarget& operator=(const DtFedTarget& orig);


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

      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, const DtString& normalization);

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

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

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

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

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

      virtual 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 ) = 0;

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

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

      //-------------------------------------------------------------------------


      virtual bool autoProvide() const;
      virtual void setAutoProvide(bool value);

      virtual bool conveyRegionDesignatorSets() const;
      virtual void setConveyRegionDesignatorSets(bool value);

      virtual bool conveyProducingFederate() const;
      virtual void setConveyProducingFederate(bool value);

      virtual bool attributeScopeAdvisory() const;
      virtual void setAttributeScopeAdvisory(bool value);

      virtual bool attributeRelevanceAdvisory() const;
      virtual void setAttributeRelevanceAdvisory(bool value);

      virtual bool objectClassRelevanceAdvisory() const;
      virtual void setObjectClassRelevanceAdvisory(bool value);

      virtual bool interactionRelevanceAdvisory() const;
      virtual void setInteractionRelevanceAdvisory(bool value);

      virtual bool serviceReporting() const;
      virtual void setServiceReporting(bool value);

      virtual bool exceptionReporting() const;
      virtual void setExceptionReporting(bool value);

      virtual bool delaySubscriptionEvaluation() const;
      virtual void setDelaySubscriptionEvaluation(bool value);

      virtual DtResignAction automaticResignAction() const;
      virtual void setAutomaticResignAction(DtResignAction value);

      virtual bool nonRegulatedGrant() const;
      virtual void setNonRegulatedGrant(bool value);

      virtual bool sendServiceReportsToFile() const;
      virtual void setSendServiceReportsToFile(bool value);

      virtual bool advisoriesUseKnownClass() const;
      virtual void setAdvisoriesUseKnownClass(bool value);

      virtual bool allowRelaxedDdm() const;
      virtual void setAllowRelaxedDdm(bool value);

      //-------------------------------------------------------------------------


      virtual unsigned int numUpdateRates() const;
      virtual void addUpdateRate(DtUpdateRateType* updateRate);
      virtual bool knownUpdateRate( const DtUpdateRateType & updateRate ) const;



      virtual unsigned int numSyncPoints() const;
      virtual void addSyncPoint(DtSynchronizationPointsType* syncName);
      virtual bool knownSyncPoint( const DtSynchronizationPointsType & syncName ) const;



      virtual unsigned int numTransports() const;
      virtual void addTransportType(DtTransportationType* transportName);
      virtual bool knownTransportType( const DtTransportationType & transportName) const;
      virtual bool transportTypeConsistencyTest(const DtTransportationType & transportName);
      virtual DtTransportType transportTypeFromTransportation( const DtString & transportTypeName) const;
      virtual DtMergeFomStatus mergeTransportTypes(DtFedTarget const& module);


      virtual unsigned int numUserSuppliedTags() const;
      virtual void addUserSuppliedTag(DtUserSuppliedTagsType* tag);
      virtual bool knownUserSuppliedTag(const DtUserSuppliedTagsType& tag) const;



      virtual unsigned int numNotes() const;
      virtual void addNote(DtNotesType* noteName);
      virtual bool knownNote(const DtNotesType & noteName) const;



      virtual unsigned int numSwitches() const;
      virtual void addSwitch(const DtString& switchName, bool switchVal);
      virtual bool knownSwitch(const DtString& switchName) const;
      virtual bool isStandardSwitch(const DtString& switchName) const;
      virtual bool switchValue(const DtString& switchName) const;
      virtual DtMergeFomStatus mergeSwitches(DtFedTarget const& module, bool allowCreateMerges);


      virtual unsigned int numTimeTypes() const;
      virtual void addTime(DtTimeType* timeName);
      virtual bool knownTime(const DtTimeType & timeName) const;
      virtual bool timeTypesSame(DtFedTarget const& module ) const;
      virtual DtMergeFomStatus mergeTimeTypes(DtFedTarget const& module);


      virtual void addBasicDataRepresentation(DtBasicDataRepresentationType * theBasicDataRepresentation);
      virtual bool knownBasicDataRepresentation(const DtBasicDataRepresentationType& theBasicDataRepresentation) const;



      virtual void addSimpleDataType(DtSimpleDatatypeType * theSimpleDataType);
      virtual bool knownSimpleDatatype(const DtSimpleDatatypeType & theSimpleDatatype) const;



      virtual void addEnumeratedDataType(DtEnumeratedDatatypeType * theEnumeratedDataType);
      virtual bool knownEnumeratedDatatype(const DtEnumeratedDatatypeType& theEnumeratedDatatype) const;



      virtual void addArrayDataType(DtArrayDatatypeType * theArrayDataType);
      virtual bool knownArrayDatatype(const DtArrayDatatypeType& theArrayDatatype) const;



      virtual void addFixedRecordDataType(DtFixedRecordDatatypeType * theFixedRecordDataType);
      virtual bool knownFixedRecordDatatype(const DtFixedRecordDatatypeType theFixedRecordDatatype) const;



      virtual void addVariantRecordDataType(DtVariantRecordDatatypeType * theVariantRecordDataType);
      virtual bool knownVariantRecordDatatype(const DtVariantRecordDatatypeType& theVariantRecordDatatype) const;



      virtual void addModelIdentification(const char * nameTag);
      virtual bool knownModelIdentification(DtString const & nameTag) const;
      virtual bool modelIdentificationSame(DtFedTarget const& module) const;


      virtual void setFomDependencies(const DtNameVector& fomDependencies);
      virtual const DtNameVector& fomDependencies();
      virtual const DtNameVector& fomDependencies() const;

      virtual void setMergeTableMask(DtU64 mergeTableMask);

      virtual bool fomTableMergeEnabled(DtMergeFomTableMask fomTableMask) const;

      virtual DtMergeFomStatus mergeTarget( DtFedTarget const& module, bool allowCreateMerges);

      virtual DtMergeFomStatus mergeSpaces( DtFedTarget const& module );

      virtual DtMergeFomStatus mergeObjectClasses(const DtFedTarget& module);

      virtual DtMergeFomStatus mergeInteractionClasses(const DtFedTarget& module);

      virtual DtMergeFomStatus postMergeCheckTarget(DtString & errorString);


      virtual void addUnresolvedAttributeTransportation(const DtString& transportationName, const DtString& className, const DtString& attrName);
      virtual void removeResolvedAttributeTransportation(const DtString& transportationName, DtNamePair classAttrPair);


      virtual void addUnresolvedInteractionTransportation(const DtString& transportationName, const DtString& interactionName);
      virtual void removeResolvedInteractionTransportation(const DtString& transportationName, const DtString& interactionName);

      virtual const DtString& modelIdentification() const;

      virtual const DtString& lastError() const;

      virtual bool isStrictChecking() const;
      virtual void setStrictChecking(bool doStrictChecking);

   public:



      static void setDefaultAutoProvide(bool onOff);
      static bool defaultAutoProvide();

      static void setDefaultConveyRegionDesignatorSets(bool onOff);
      static bool defaultConveyRegionDesignatorSets();

      static void setDefaultConveyProducingFederate(bool onOff);
      static bool defaultConveyProducingFederate();

      static void setDefaultObjectClassRelevanceAdvisory(bool onOff);
      static bool defaultObjectClassRelevanceAdvisory();

      static void setDefaultAttributeRelevanceAdvisory(bool onOff);
      static bool defaultAttributeRelevanceAdvisory();

      static void setDefaultAttributeScopeAdvisory(bool onOff);
      static bool defaultAttributeScopeAdvisory();

      static void setDefaultInteractionRelevanceAdvisory(bool onOff);
      static bool defaultInteractionRelevanceAdvisory();

      static void setDefaultServiceReporting(bool onOff);
      static bool defaultServiceReporting();

      static void setDefaultExceptionReporting(bool onOff);
      static bool defaultExceptionReporting();

      static void setDefaultAutomaticResignAction(DtResignAction val);
      static DtResignAction defaultAutomaticResignAction();

      static void setDefaultDelaySubscriptionEvaluation(bool value);
      static bool defaultDelaySubscriptionEvaluation();

      static void setDefaultNonRegulatedGrant(bool value);
      static bool defaultNonRegulatedGrant();

      static void setDefaultSendServiceReportsToFile(bool value);
      static bool defaultSendServiceReportsToFile();

      static void setDefaultAdvisoriesUseKnownClass(bool value);
      static bool defaultAdvisoriesUseKnownClass();

      static void setDefaultAllowRelaxedDdm(bool value);
      static bool defaultAllowRelaxedDdm();


      static char const* enumAsString(DtResignAction action);

      static char const* enumAsString(DtMergeFomTableMask mergeTable);

   protected:

      typedef void (*DtSwitchSetterFunc)(DtFedTarget* target, bool enableSwitch);

      typedef bool (*DtSwitchGetterFunc)(DtFedTarget const* target);

      typedef std::map<DtString, DtSwitchSetterFunc> DtSwitchSetterMap;

      typedef std::map<DtString, DtSwitchGetterFunc> DtSwitchGetterMap;

      void initSwitchSetters();


      virtual void addUnresolvedObjectDimension(const DtString& dimensionName, const DtString& objectClassName);
      virtual void removeResolvedObjectDimension(const DtString& dimensionName, const DtString& objectClassName);


      virtual void addUnresolvedAttributeDimension(const DtString& dimensionName, const DtString& className,
         const DtString& attrName);
      virtual void removeResolvedAttribute(const DtString& dimensionName, DtNamePair classAttrPair);


      virtual void addUnresolvedInteractionDimension(const DtString& dimensionName, const DtString& interactionName);
      virtual void removeResolvedInteractionDimension(const DtString& dimensionName, const DtString& interactionName);


      virtual void mergeUnresolved(DtFedTarget const & module);
      virtual bool resolveObjectModelIdentification(DtString & errorString);
      virtual bool resolveObjectClasses(DtString & errorString, bool& fomReadError);
      virtual bool resolveInteractionClasses(DtString & errorString, bool& fomReadError);
      virtual bool resolveAttributes(DtString & errorString, bool& fomReadError);
      virtual bool resolveParameters(DtString & errorString, bool& fomReadError);
      virtual bool resolveDimensions(DtString & errorString, bool& fomReadError);
      // Not necessary
      virtual bool resolveTimeRepresentations(DtString & errorString);
      // Not Necessary
      virtual bool resolveUserSuppliedTags(DtString & errorString);
      // Not Necessary
      virtual bool resolveSynchronizationPoints(DtString & errorString);
      virtual bool resolveTranportationTypes(DtString & errorString);
      virtual bool resolveUpdateRates(DtString & errorString);
      virtual bool resolveSwitches(DtString & errorString);
      virtual void checkSpecificSwitch(const DtString & switchName, bool &mySwitchMissing, DtString &mySwitchesError);
      // Not necessary
      virtual bool resolveDatatypes(DtString & errorString);
      // Not Necessary
      virtual bool resolveNotes(DtString & errorString);
      // Not Necessary
      virtual bool resolveServiceUsage(DtString & errorString);
      virtual void unionUnresolvedClassDimensions(DtNameToNameSetMap& thisUnresolvedClassDimensions,
         DtNameToNameSetMap const& otherUnresolvedObjectDimensions);
      virtual void unionUnresolvedAttributeDimensions(const DtNameToNamePairSetMap& unresolvedAttributeDimensions);
      virtual void unionUnresolvedAttributeTransportation(const DtNameToNamePairSetMap& unresolvedAttributetransportations);
      virtual void unionUnresolvedInteractionTransportation(const DtNameToNameSetMap& unresolvedInteractiontransportations);

      virtual bool checkStringsIgnoringWhiteSpaceAndNewline(const DtString & left, const DtString & right);




      static void setAutoProvide(DtFedTarget*, bool onOff);
      static bool autoProvide(DtFedTarget const*);
      static void setConveyRegionDesignatorSets(DtFedTarget*, bool onOff);
      static bool conveyRegionDesignatorSets(DtFedTarget const*);
      static void setConveyProducingFederate(DtFedTarget*, bool onOff);
      static bool conveyProducingFederate(DtFedTarget const*);
      static void setObjectClassRelevanceAdvisory(DtFedTarget*, bool onOff);
      static bool objectClassRelevanceAdvisory(DtFedTarget const*);
      static void setAttributeRelevanceAdvisory(DtFedTarget*, bool onOff);
      static bool attributeRelevanceAdvisory(DtFedTarget const*);
      static void setAttributeScopeAdvisory(DtFedTarget*, bool onOff);
      static bool attributeScopeAdvisory(DtFedTarget const*);
      static void setInteractionRelevanceAdvisory(DtFedTarget*, bool onOff);
      static bool interactionRelevanceAdvisory(DtFedTarget const*);
      static void setServiceReporting(DtFedTarget*, bool onOff);
      static bool serviceReporting(DtFedTarget const*);
      static void setExceptionReporting(DtFedTarget*, bool onOff);
      static bool exceptionReporting(DtFedTarget const*);
      static void setDelaySubscriptionEvaluation(DtFedTarget*, bool onOff);
      static bool delaySubscriptionEvaluation(DtFedTarget const*);
      static void setNonRegulatedGrant(DtFedTarget*, bool onOff);
      static bool nonRegulatedGrant(DtFedTarget const*);
      static void setSendServiceReportsToFile(DtFedTarget*, bool onOff);
      static bool sendServiceReportsToFile(DtFedTarget const*);
      static void setAdvisoriesUseKnownClass(DtFedTarget*, bool onOff);
      static bool advisoriesUseKnownClass(DtFedTarget const*);
      static void setAllowRelaxedDdm(DtFedTarget*, bool onOff);
      static bool allowRelaxedDdm(DtFedTarget const*);


   protected:


#define DEFINE_COMPONENT_SET_TYPEDEF(componentType) \
      typedef std::set<std::shared_ptr<componentType>, FomTypeCompare<componentType>> componentType##Set
      DEFINE_COMPONENT_SET_TYPEDEF(DtNotesType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtSynchronizationPointsType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtUserSuppliedTagsType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtTransportationType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtBasicDataRepresentationType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtSimpleDatatypeType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtEnumeratedDatatypeType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtArrayDatatypeType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtFixedRecordDatatypeType);
      DEFINE_COMPONENT_SET_TYPEDEF(DtVariantRecordDatatypeType);
      typedef std::set< std::shared_ptr<DtTimeType>> DtTimeTypeSet;

      DtFomType myFomType;

      // FOM components
      DtString myModelIdentification;
      DtNameVector myFomDependencies;
      DtTimeTypeSet myTimeTypes;
      DtUserSuppliedTagsTypeSet myUserSuppliedTags;
      DtSynchronizationPointsTypeSet mySyncPoints;
      DtTransportationTypeSet myTransportTypes;
      DtUpdateRateSetT myUpdateRates;
//       std::set<DtNotesType> myNotes;
      DtNotesTypeSet myNotes;

      DtSwitchesMap mySwitches;

      DtBasicDataRepresentationTypeSet myBasicDataRepTypes;
      DtSimpleDatatypeTypeSet mySimpleDatatypeTypes;
      DtEnumeratedDatatypeTypeSet myEnumeratedDatatypeTypes;
      DtArrayDatatypeTypeSet myArrayDatatypeTypes;
      DtFixedRecordDatatypeTypeSet myFixedRecordDatatypeTypes;
      DtVariantRecordDatatypeTypeSet myVariantRecordDatatypeTypes;

      // Mask that determines which tables are merged
      DtU64 myFomTableMergeMask;


      bool myAdvisoriesUseKnownClass;
      bool myAllowRelaxedDdm;
      bool myAttributeScopeAdvisory;
      bool myAttributeRelevanceAdvisory;
      DtResignAction myAutomaticResignAction;
      bool myAutomaticResignActionWasSet;
      bool myAutoProvide;
      bool myConveyRegionDesignatorSets;
      bool myConveyProducingFederate;
      bool myDelaySubscriptionEvaluation;
      bool myExceptionReporting;
      bool myInteractionRelevanceAdvisory;
      bool myObjectClassRelevanceAdvisory;
      bool myNonRegulatedGrant;
      bool mySendServiceReportsToFile;
      bool myServiceReporting;

      // Bookkeeping/configuration
      bool myStrictChecking;
      DtSwitchSetterMap mySwitchSetters;
      DtSwitchGetterMap mySwitchGetters;

      bool myMergingFomModule;

      DtNameToNameSetMap myUnresolvedObjectDimensions;
      DtNameToNamePairSetMap myUnresolvedAttributeDimensions;
      DtNameToNameSetMap myUnresolvedInteractionDimensions;
      DtNameToNamePairSetMap myUnresolvedAttributeTransportations;
      DtNameToNameSetMap myUnresolvedInteractionTransportations;

      mutable DtString myLastError;
      bool myErrorFlag;

      const DtString myAdvisoriesUseKnownClassTag = "advisoriesUseKnownClass";
      const DtString myAllowRelaxedDdmTag = "allowRelaxedDDM";
      const DtString myAttributeRelevanceAdvisoryTag = "attributeRelevanceAdvisory";
      const DtString myAttributeScopeAdvisoryTag = "attributeScopeAdvisory";
      const DtString myAutomaticResignActionTag = "automaticResignAction";
      const DtString myAutoProvideTag = "autoProvide";
      const DtString myConveyProducingFederateTag = "conveyProducingFederate";
      const DtString myConveyRegionDesignatorSetsTag = "conveyRegionDesignatorSets";
      const DtString myDelaySubscriptionEvaluationTag = "delaySubscriptionEvaluation";
      const DtString myExceptionReportingTag = "exceptionReporting";
      const DtString myInteractionRelevanceAdvisoryTag = "interactionRelevanceAdvisory";
      const DtString myNonRegulatedGrantTag = "nonRegulatedGrant";
      const DtString myObjectClassRelevanceAdvisoryTag = "objectClassRelevanceAdvisory";
      const DtString myServiceReportingTag = "serviceReporting";
      const DtString mySendServiceReportsToFileTag = "sendServiceReportsToFile";

   protected:

      static bool theDefaultAdvisoriesUseKnownClass;
      static bool theDefaultAllowRelaxedDdm;
      static bool theDefaultAttributeRelevanceAdvisory;
      static bool theDefaultAttributeScopeAdvisory;
      static DtResignAction theDefaultAutomaticResignAction;
      static bool theDefaultAutoProvide;
      static bool theDefaultConveyProducingFederate;
      static bool theDefaultConveyRegionDesignatorSets;
      static bool theDefaultDelaySubscriptionEvaluation;
      static bool theDefaultExceptionReporting;
      static bool theDefaultInteractionRelevanceAdvisory;
      static bool theDefaultObjectClassRelevanceAdvisory;
      static bool theDefaultNonRegulatedGrant;
      static bool theDefaultServiceReporting;
      static bool theDefaultSendServiceReportsToFile;

   };
  
#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif