disTranslator.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2016 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

// Disable warning about missing operators.
// Comparison and assignment operators are declared but not defined
// to prevent their usage, but this causes a warning in template classes.
#pragma warning( disable : 4661 )

#include <disBroker/dllExport.h>
#include <disBroker/globalIdMapper.h>

#include <broker/baseObjectTranslator.h>
#include <broker/baseInteractionTranslator.h>

#include <portal/pReflectedObjectManagerTypes.h>
#include <portal/pObjectPublisherTypes.h>

// All DIS Translators must have the following template arguments:
// The integer define of the DtPortalMessageKind,
// The PortalObject this message translates,
// The Reflected Portal Object class the message translates
// The Reflected DIS Object class
// The reflected list of objects
// The state repository class of the DIS Object
// The publisher class of the DIS Object
#define DIS_TEMPLATE_LIST \
   template \
   < class T_PortalObject \
   , class T_PortalReflectedObject \
   , class T_DisReflectedObject \
   , class T_DisReflectedObjectList \
   , class T_DisObjectStateRepository \
   , class T_DisObjectPublisher>

#define DIS_TEMPLATE_FUNCTION \
   T_PortalObject, T_PortalReflectedObject, \
   T_DisReflectedObject, T_DisReflectedObjectList, \
   T_DisObjectStateRepository, T_DisObjectPublisher

class DtInteraction;
class DtObjectPublisher;
class DtStateRepository;
class DtReflectedObject;

namespace MAKVrExchange
{

   class DtRequestTranslationDiagnosticMessage;

   namespace DtDisBroker
   {

      class DtDisBroker;

      DIS_TEMPLATE_LIST
      class DtDisObjectTranslator
         : public DtBaseObjectTranslator<T_PortalObject,T_PortalReflectedObject>
      {
      public:

         typedef enum
         {
            none = 0,
            discover = 1, 
            update = 2,   
            remove = 3    
         } UpdateType;

         typedef DtDisObjectTranslator<DIS_TEMPLATE_FUNCTION> ParentClass;

         typedef DtBaseObjectTranslator<T_PortalObject,T_PortalReflectedObject> BaseTranslatorClass;

      public:

         DtDisObjectTranslator( DtBroker* broker,
            const DtString& name, DtPortalMessageKind kind );

         virtual ~DtDisObjectTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual void forceUpdateAll();

         virtual void tick();

         virtual DtDisBroker* disBroker();
         virtual const DtDisBroker* disBroker() const;

      protected:


         virtual void initializeDisCallbacks();
         virtual void removeDisCallbacks();



         virtual DtBrokerObject* createBrokerObject( const DtReflectedObject* refObj );
         virtual DtBrokerObject* createBrokerObject( const DtPortalReflectedObject* refObj );

         virtual DtBrokerObject* findBrokerObject( const DtReflectedObject* refObj );
         virtual DtBrokerObject* findBrokerObject( const DtPortalReflectedObject* refObj );

         virtual DtBrokerObject* findBrokerObject( const DtString& objectName );

         virtual DtBrokerObject* releaseBrokerObject( const DtReflectedObject* refObj );
         virtual DtBrokerObject* releaseBrokerObject( const DtPortalReflectedObject* refObj );



         static bool disDiscoveryCriteria( DtReflectedObject* refObj, void* usr );

         static void disObjectAddedCb( T_DisReflectedObject* refObj, void* usr );

         static void disObjectUpdatedCb( T_DisReflectedObject* refObj, void* usr );

         static void disObjectDeletedCb( T_DisReflectedObject* refObj, void* usr );



         virtual bool isPortalDiscoverable( const DtPortalReflectedObject* refObj );

         virtual bool isDisPublishable( DtBrokerObject* brokerObj,
            const T_PortalReflectedObject* refObj );



         virtual bool isDisDiscoverable( const DtReflectedObject* refObj );



         virtual void callObjectDiscoverCallbacks( const DtBrokerObject* obj );
         virtual void callObjectUpdateCallbacks( const DtBrokerObject* obj );
         virtual void callObjectRemoveCallbacks( const DtBrokerObject* obj );



         virtual void discoverDisObject( T_DisReflectedObject& obj );
         virtual void discoverPortalObject( const T_PortalReflectedObject& obj );



         virtual void createDisPublisher( DtBrokerObject* brokerObj );

         virtual DtString disObjectName( const T_PortalReflectedObject* refObj ) const;

         virtual DtEntityIdentifier mapIdentifier( const T_PortalReflectedObject* refObj,
            const DtString& identifier );

         virtual DtEntityIdentifier mapObjectId( const DtEntityIdentifier& identifier );

         virtual DtObjectPublisher* instantiateDisPublisher(
            const T_PortalReflectedObject* refObj, const DtEntityIdentifier& name );

         virtual bool performDisGlobalIdMapping( const DtObjectPublisher* publisher,
            const T_PortalReflectedObject& refObj,
            DtGlobalIdMapper::ObjectType type = DtGlobalIdMapper::EntityType,
            int systemId = DtGlobalIdMapper::NoSystemId,
            int beamId = DtGlobalIdMapper::NoBeamId );

         virtual void createPortalPublisher( DtBrokerObject* brokerObj );

         virtual DtString portalObjectName( const T_DisReflectedObject* refObj ) const;

         virtual bool performPortalGlobalIdMapping(
            const DtPortalObjectPublisherTemplate<T_PortalObject>* publisher,
            const T_DisReflectedObject& refObj,
            DtGlobalIdMapper::ObjectType type = DtGlobalIdMapper::EntityType,
            int systemId = DtGlobalIdMapper::NoSystemId,
            int beamId = DtGlobalIdMapper::NoBeamId );



         virtual void receiveDisUpdate( T_DisReflectedObject& obj );
         virtual void receivePortalUpdate( const T_PortalReflectedObject& obj );



         virtual void updateDisBrokerObject( DtBrokerObject* brokerObj,
            const T_DisObjectStateRepository& sr );
         virtual void updatePortalBrokerObject( DtBrokerObject* brokerObj,
            const T_PortalObject& sr );


         virtual void updateFilteredState( DtBrokerObject* brokerObj,
            DtPortalObjectPublisherTemplate<T_PortalObject>* publisher,
            T_DisReflectedObject* refObj );

         virtual bool filterLocation( const DtReflectedObject& refObj,
            const DtVector& location );


         virtual void removeDisObject( const DtReflectedObject& refObj );
         virtual void removePortalObject( const T_PortalReflectedObject& refObj );



         virtual void deleteDisPublisher( DtBrokerObject* brokerObj );
         virtual void deletePortalPublisher( DtBrokerObject* brokerObj );


         static void requestTransDiagCb( const DtRequestTranslationDiagnosticMessage& msg, void* usr );

         virtual void requestTransDiagCb( const DtRequestTranslationDiagnosticMessage& msg );

         virtual void printIncomingOutgoingStateReps(
            const DtPortalObject& incoming, const DtStateRepository& outgoing ) const;

         virtual void printIncomingOutgoingStateReps(
            const DtStateRepository& incoming, const DtPortalObject& outgoing ) const;

         virtual void performPortalDebugging( const DtString& objectName );

         virtual void performPortalDebugging( const DtPortalObject& incoming,
            const DtStateRepository& outgoing );

         virtual void performPortalDebugging( const DtStateRepository& incoming,
            const DtPortalObject& outgoing );

         virtual void printDumpGuiToText( const DtBrokerObject& brokerObj,
            UpdateType ut ) const;

         virtual unsigned int numObjects() const;

         virtual void shutdown();

      public:

         virtual T_PortalObject* translate( T_PortalObject* destination,
            const T_DisObjectStateRepository& source,
            const T_DisReflectedObject& refObj ) = 0;

         virtual T_DisObjectStateRepository* translate(
            T_DisObjectStateRepository* destination, const T_PortalObject& source,
            const T_PortalReflectedObject& refObj ) = 0;

      private:

         DtDisObjectTranslator( const DtDisObjectTranslator& other );

         DtDisObjectTranslator& operator = ( const DtDisObjectTranslator& other );

         bool operator == ( const DtDisObjectTranslator& rightOperand ) const;

         bool operator != ( const DtDisObjectTranslator& rightOperand ) const;

      protected:

         T_DisReflectedObjectList* myDisReflectedList;

         typedef std::pair<DtTime,bool> LocationFilteringInfo;
         typedef std::map<const DtReflectedObject*,LocationFilteringInfo> LocationFilteringMap;
         LocationFilteringMap myLocationFilteringMap;

         typedef std::map<const DtReflectedObject*,DtBrokerObject*> DisToPortalReflectedMap;
         typedef std::map<const DtPortalReflectedObject*,DtBrokerObject*> PortalToDisReflectedMap;

         DisToPortalReflectedMap myPortalPublisherMap;
         PortalToDisReflectedMap myDisPublisherMap;

         typedef std::set<DtString> TransDebugObjectNamesSet;
         TransDebugObjectNamesSet myTransDebugNames;

      };


      template <class PortalInterType,class DisInterType>
      class DtDisInteractionTranslator
         : public DtBaseInteractionTranslator<PortalInterType>
      {
      public:

         typedef DtDisInteractionTranslator<PortalInterType,DisInterType> ParentClass;

      public:

         DtDisInteractionTranslator( DtBroker* broker,
            const DtString& name, DtPortalMessageKind kind );

         virtual ~DtDisInteractionTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual DtDisBroker* disBroker();
         virtual const DtDisBroker* disBroker() const;

         virtual void tick();

      protected:


         virtual void initializeDisCallbacks();
         virtual void removeDisCallbacks();



         static void receiveDisInteraction( DisInterType* inter, void* usr );
         virtual void receiveDisInteraction( const DisInterType& inter );


         virtual void receivePortalInteraction( const PortalInterType& inter );


         virtual void createInteraction( const PortalInterType& inter );
         virtual void createPortalInteraction( const DisInterType& inter );


         virtual PortalInterType* translate( PortalInterType* destination,
            const DisInterType& source ) = 0;

         virtual DisInterType* translate( DisInterType* destination,
            const PortalInterType& source ) = 0;

         virtual void printIncomingOutgoingInteractions( const DtPortalInteraction& incoming,
            const DtInteraction& outgoing ) const;

         virtual void printIncomingOutgoingInteractions( const DtInteraction& incoming,
            const DtPortalInteraction& outgoing ) const;

         virtual bool testGlobalIdMapping( const DtString& idName, const DtString& id );

         virtual void shutdown();

      private:

         DtDisInteractionTranslator( const DtDisInteractionTranslator& other );

         DtDisInteractionTranslator& operator = ( const DtDisInteractionTranslator& other );

         bool operator == ( const DtDisInteractionTranslator& rightOperand ) const;

         bool operator != ( const DtDisInteractionTranslator& rightOperand ) const;

      protected:

         typedef std::vector<PortalInterType> InteractionWaitList;
         InteractionWaitList myInteractionWaitList;

      };

   }
}

#define _disTranslator_INL_
#include <disBroker/disTranslator.inl>
#undef _disTranslator_INL_