vlFedTarget.h

Go to the documentation of this file.

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


#include <map>
#include <set>
#include <vector>
#include <cmath>
#include "vlMachineTypes.h"
#include <mtl/fedTargetHelper.h>
#include <vlutil/vlString.h>
#include "vlutil/vlUtil.h"
#include "vlutil/vlSmartPointers.h"
#include "vlutil/vlFedTargetTypes.h"

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

   // Forward Declaration
   /*class DtTimeType;
   class DtUserSuppliedTagsType;
   class DtSynchronizationPointsType;
   class DtTransportationType;
   class DtUpdateRateType;

   class DtBasicDataRepresentationType;
   class DtSimpleDatatypeType;
   class DtEnumeratedDatatypeType;
   class DtArrayDatatypeType;
   class DtFixedRecordDatatypeType;
   class DtVariantRecordDatatypeType;

   class DtNotesType;*/

   typedef  std::set<DtBoost::shared_ptr<DtUpdateRateType>, FomTypeCompare<DtUpdateRateType> > DtUpdateRateSetT;
   typedef  std::set<DtBoost::shared_ptr<DtSynchronizationPointsType>, FomTypeCompare<DtSynchronizationPointsType> > DtSyncPointSetT;
   typedef  std::set<DtBoost::shared_ptr<DtTransportationType>, FomTypeCompare<DtTransportationType> > DtTransportationSetT;
   typedef  std::set<DtBoost::shared_ptr<DtNotesType>, FomTypeCompare<DtNotesType> > DtNotesSetT;
   typedef  std::set< DtBoost::shared_ptr<DtTimeType> > DtTimeTypeSetT;
   typedef  std::set< DtBoost::shared_ptr<DtUserSuppliedTagsType> > DtUserDefinedTagsSetT;
   typedef  std::pair<DtString, DtString> ClassAttributeNamePair;

   typedef  std::pair<DtString, DtString > DtNameTypePair; 

   typedef  std::set<DtNameTypePair> DtNameTypePairSet;
   typedef  std::pair<DtString, ClassAttributeNamePair> DtNameClassAttributeNamePair;
   typedef  std::set<DtNameClassAttributeNamePair> DtNameClassAttributeNamePairSet;
   
   enum DtFomType
   {
      DtFomInvalid = 0,
      DtFom13 = 1,
      DtFom1516 = 2,
      DtFom1516E = 3
   };

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

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

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

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

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

      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 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 UpdateRateConsistencyTest( const DtUpdateRateType & updateRate );
      virtual bool knownUpdateRate( const DtUpdateRateType & updateRate ) const;
      virtual unsigned int numUpdateRates() const;
      virtual void addUpdateRate( DtUpdateRateType * updateRate);

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

      virtual bool knownTransportType( const DtTransportationType & transportName) const;
      virtual bool TransportTypeConsistencyTest(const DtTransportationType & transportName);
      virtual unsigned int numTransports() const;
      virtual void addTransportType( DtTransportationType * transportName );
      virtual DtTransportType transportTypeFromTransportation( const DtString & transportTypeName) const;

      virtual bool knownUserDefinedTag(const DtUserSuppliedTagsType & tagName) const;
      virtual unsigned int numUserDefinedTags() const;
      virtual bool userDefinedTagsSame(DtFedTarget const& module ) const;
      virtual void addUserDefinedTag(DtUserSuppliedTagsType * tagName);
      virtual DtMergeFomStatus mergeUserDefinedTypes(DtFedTarget const& module );

      virtual bool NoteConsistencyTest( const DtNotesType & syncName );
      virtual bool knownNote(const DtNotesType & noteName) const;
      virtual void addNote( DtNotesType * noteName );
      virtual unsigned int numNotes() const;
      virtual DtMergeFomStatus mergeSwitches(DtFedTarget const& module);
      //bool DtFedTarget::notesSame(DtFedTarget const& module ) const;

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

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


      virtual void addModelIdentification(const char * nameTag);

      virtual void setFomDependencies(const std::vector<DtString>& fomDependencies);
      virtual const std::vector<DtString>& fomDependencies();
      virtual const std::vector<DtString>& fomDependencies() const;


      virtual DtMergeFomStatus mergeTarget( DtFedTarget const& module );
      virtual DtMergeFomStatus mergeSpaces( DtFedTarget const& module );
      virtual DtMergeFomStatus mergeObjectClasses(const DtFedTarget& module);
      virtual DtMergeFomStatus mergeInteractionClasses(const DtFedTarget& module);
      virtual DtMergeFomStatus mergeUpdateRates(DtFedTarget const& module);
      virtual DtMergeFomStatus mergeSyncPoints(DtFedTarget const& module );
      virtual DtMergeFomStatus mergeTransportTypes(DtFedTarget const& module );


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

      // Post Merge checks
      virtual DtMergeFomStatus postMergeCheckTarget(DtString & errorString);

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

      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 addBasicDataRepresentation( DtBasicDataRepresentationType * theBasicDataRepresentation );
      virtual void addSimpleDataType( DtSimpleDatatypeType * theSimpleDataType );
      virtual void addArrayDataType( DtArrayDatatypeType * theArrayDataType );
      virtual void addEnumeratedDataType( DtEnumeratedDatatypeType * theEnumeratedDataType );
      virtual void addFixedRecordDataType( DtFixedRecordDatatypeType * theFixedRecordDataType );
      virtual void addVariantRecordDataType( DtVariantRecordDatatypeType * theVariantRecordDataType );
      virtual bool knownModelIdentification( DtString const & nameTag ) const;
      virtual bool modelIdentificationSame(DtFedTarget const& module ) const;
      /*protected:*/
      DtFomType myFomType;

      DtString myModelIdentification;
      bool myAutoProvide;
      bool myConveyRegionDesignatorSets;
      bool myConveyProducingFederate;
      bool myAttributeScopeAdvisory;
      bool myAttributeRelevanceAdvisory;
      bool myObjectClassRelevanceAdvisory;
      bool myInteractionRelevanceAdvisory;
      bool myServiceReporting;
      bool myExceptionReporting;
      bool myDelaySubscriptionEvaluation;
      DtResignAction myAutomaticResignAction;

      bool isStrictMerge;
      bool myCheckSwitches;




      DtTimeTypeSetT myTimeTypes;
      DtUserDefinedTagsSetT myUserDefinedTags;
      DtSyncPointSetT mySyncPoints;
      DtTransportationSetT myTransportTypes;
      DtUpdateRateSetT myUpdateRates;
      DtNotesSetT myNotes;

      std::map< DtString, bool > mySwitches;



      typedef std::set<DtBoost::shared_ptr<DtBasicDataRepresentationType>, FomTypeCompare<DtBasicDataRepresentationType> > DtBasicDataRepresentationSetT;
      typedef std::set<DtBoost::shared_ptr<DtSimpleDatatypeType>, FomTypeCompare<DtSimpleDatatypeType> > DtSimpleDatatypeSetT;
      typedef std::set<DtBoost::shared_ptr<DtEnumeratedDatatypeType>, FomTypeCompare<DtEnumeratedDatatypeType> > DtEnumeratedDatatypeSetT;
      typedef std::set<DtBoost::shared_ptr<DtArrayDatatypeType>, FomTypeCompare<DtArrayDatatypeType> > DtArrayDatatypeSetT;
      typedef std::set<DtBoost::shared_ptr<DtFixedRecordDatatypeType>, FomTypeCompare<DtFixedRecordDatatypeType> > DtFixedRecordDatatypeSetT;
      typedef std::set<DtBoost::shared_ptr<DtVariantRecordDatatypeType>, FomTypeCompare<DtVariantRecordDatatypeType> > DtVariantRecordDatatypeSetT;

      DtBasicDataRepresentationSetT myBasicDataRepTypes;
      DtSimpleDatatypeSetT mySimpleDatatypeTypes;
      DtEnumeratedDatatypeSetT myEnumeratedDatatypeTypes;
      DtArrayDatatypeSetT myArrayDatatypeTypes;
      DtFixedRecordDatatypeSetT myFixedRecordDatatypeTypes;
      DtVariantRecordDatatypeSetT myVariantRecordDatatypeTypes;

      virtual bool basicDataRepresentationConsistencyTest ( const DtBasicDataRepresentationType & theBasicDataRepresentation);
      virtual bool knownBasicDataRepresentation( const DtBasicDataRepresentationType & theBasicDataRepresentation) const;
      virtual bool basicDataRepresentationSame(DtFedTarget const & module) const;
      virtual DtMergeFomStatus mergeBasicDataRepresentation(DtFedTarget const & module);

      virtual bool simpleDatatypeConsistencyTest( const DtSimpleDatatypeType & theSimpleDatatype);
      virtual bool knownSimpleDatatype( const DtSimpleDatatypeType & theSimpleDatatype) const;
      virtual bool simpleDatatypeSame(DtFedTarget const & module) const;
      virtual DtMergeFomStatus mergeSimpleDatatype(DtFedTarget const & module);

      virtual bool enumeratedDatatypeConsistencyTest( const DtEnumeratedDatatypeType & theSimpleDatatype);
      virtual bool knownEnumeratedDatatype(const DtEnumeratedDatatypeType & theEnumeratedDatatype) const;
      virtual bool enumeratedDatatypeSame(DtFedTarget const & module) const;
      virtual DtMergeFomStatus mergeEnumeratedDatatype(DtFedTarget const & module);

      virtual bool arrayDatatypeConsistencyTest( const DtArrayDatatypeType & DtArrayDatatypeType);
      virtual bool knownArrayDatatype(const DtArrayDatatypeType & theArrayDatatype) const;
      virtual bool arrayDatatypeSame(DtFedTarget const & module) const;
      virtual DtMergeFomStatus mergeArrayDatatypeType(DtFedTarget const & module);

      virtual bool fixedRecordDatatypeConsistencyTest(const DtFixedRecordDatatypeType theFixedRecordDatatype);
      virtual bool knownFixedRecordDatatype(const DtFixedRecordDatatypeType theFixedRecordDatatype) const;
      virtual bool fixedRecordDatatypeSame(DtFedTarget const & module) const;
      virtual DtMergeFomStatus mergeFixedRecordDatatype(DtFedTarget const & module);

      virtual bool variantRecordDatatypeConsistencyTest(const DtVariantRecordDatatypeType & theVariantRecordDatatype);
      virtual bool knownVariantRecordDatatype(const DtVariantRecordDatatypeType & theVariantRecordDatatype) const;
      virtual bool variantRecordDatatypeSame(DtFedTarget const & module) const;
      DtMergeFomStatus mergeVariantRecordDatatype(DtFedTarget const & module);

      virtual void addUnresolvedAttributeTransportation( const DtString& transportationName, const DtString& className, const DtString& attrName );
      virtual void removeResolvedAttributeTransportation( const DtString& transportationName, ClassAttributeNamePair classAttrPair );
      virtual void addUnresolvedInteractionTransportation( const DtString& transportationName, const DtString& interactionName );
      virtual void removeResolvedInteractionTransportation( const DtString& transportationName, const DtString& interactionName );

      virtual DtString& lastError();

      DtString myLastError;
      bool myErrorFlag;


      bool myMergingFomModule;

   protected:

      std::map<DtString, std::set<ClassAttributeNamePair> > unresolvedAttributeDimensions;
      std::map<DtString, std::set<DtString> > unresolvedInteractionDimensions;

      std::map<DtString, std::set<ClassAttributeNamePair> > unresolvedAttributeTransportations;
      std::map<DtString, std::set<DtString> > unresolvedInteractionTransportations;

      virtual void addUnresolvedAttributeDimension( const DtString& dimensionName, const DtString& className, const DtString& attrName );
      virtual void removeResolvedAttribute( const DtString& dimensionName, ClassAttributeNamePair 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 void unionUnresolvedAttributeDimensions(const std::map<DtString, std::set<ClassAttributeNamePair> >& unresolvedAttributeDimensions);
      virtual void unionUnresolvedInteractionDimensions(const std::map<DtString, std::set<DtString> >& unresolvedInteractionDimensions);

      virtual void unionUnresolvedAttributeTransportation(const std::map<DtString, std::set<ClassAttributeNamePair> >& unresolvedAttributetransportations);
      virtual void unionUnresolvedInteractionTransportation(const std::map<DtString, std::set<DtString> >& unresolvedInteractiontransportations);
      
      virtual bool checkStringsIgnoringWhiteSpaceAndNewline(const DtString & left, const DtString & right);
      
      static bool theDefaultAutoProvide;
      static bool theDefaultConveyRegionDesignatorSets;
      static bool theDefaultConveyProducingFederate;
      static bool theDefaultObjectClassRelevanceAdvisory;
      static bool theDefaultAttributeRelevanceAdvisory;
      static bool theDefaultAttributeScopeAdvisory;
      static bool theDefaultInteractionRelevanceAdvisory;
      static bool theDefaultServiceReporting;
      static bool theDefaultExceptionReporting;
      static DtResignAction theDefaultAutomaticResignAction;

   private:

      std::vector<DtString> myFomDependencies;

   };

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif