tenaTranslator.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 <tenaBroker/dllExport.h>
#include <tenaBroker/globalIdMapper.h>

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

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

#include <vl/globalObjectDesignator.h>

// All TENA 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 TENA Object class
// The reflected list of objects
// The state repository class of the TENA Object
// The publisher class of the TENA Object
#define TENA_TEMPLATE_LIST \
   template \
   < class T_PortalObject \
   , class T_PortalReflectedObject \
   , class T_TenaReflectedObject \
   , class T_TenaReflectedObjectList \
   , class T_TenaObjectStateRepository \
   , class T_TenaObjectPublisher>

#define TENA_TEMPLATE_FUNCTION \
   T_PortalObject, T_PortalReflectedObject, \
   T_TenaReflectedObject, T_TenaReflectedObjectList, \
   T_TenaObjectStateRepository, T_TenaObjectPublisher

class DtStateRepository;

namespace MAKVrExchange
{

   class DtRequestTranslationDiagnosticMessage;

   namespace DtTenaBroker
   {

      class DtTenaBroker;
      class DtInteraction;
      class DtReflectedObject;
      class DtObjectPublisher;

      TENA_TEMPLATE_LIST
      class DtTenaObjectTranslator
         : public DtBaseObjectTranslator<T_PortalObject,T_PortalReflectedObject>
      {
      public:

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

         typedef DtTenaObjectTranslator<TENA_TEMPLATE_FUNCTION> ParentClass;

         typedef DtBaseObjectTranslator<T_PortalObject,T_PortalReflectedObject> BaseTranslatorClass;

      public:

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

         virtual ~DtTenaObjectTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual void forceUpdateAll();

         virtual void tick();

         virtual bool isThrottlingRateOk( T_TenaObjectPublisher* publisher,
            DtBrokerObject* brokerObj );

         virtual DtTenaBroker* tenaBroker();
         virtual const DtTenaBroker* tenaBroker() const;

         virtual void shutdown();

      protected:


         virtual void initializeTenaCallbacks();
         virtual void removeTenaCallbacks();



         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 tenaDiscoveryCriteria( DtReflectedObject* refObj, void* usr );

         static void tenaObjectAddedCb( T_TenaReflectedObject* refObj, void* usr );

         static void tenaObjectUpdatedCb( T_TenaReflectedObject* refObj, void* usr );

         static void tenaObjectDeletedCb( T_TenaReflectedObject* refObj, void* usr );



         virtual bool isPortalDiscoverable( const DtPortalReflectedObject* refObj );

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



         virtual bool isTenaDiscoverable( const DtReflectedObject* refObj );



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



         virtual void discoverTenaObject( T_TenaReflectedObject& obj );
         virtual void discoverPortalObject( const T_PortalReflectedObject& obj );



         virtual void createTenaPublisher( DtBrokerObject* brokerObj );

         virtual DtString tenaObjectName( const T_PortalReflectedObject* refObj ) const;

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

         virtual DtEntityIdentifier mapObjectId( const DtEntityIdentifier& identifier );

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

         virtual bool performTenaGlobalIdMapping( 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_TenaReflectedObject* refObj ) const;

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



         virtual void receiveTenaUpdate( T_TenaReflectedObject& obj );
         virtual void receivePortalUpdate( const T_PortalReflectedObject& obj );



         virtual void updateTenaBrokerObject( DtBrokerObject* brokerObj,
            const T_TenaObjectStateRepository& sr );
         virtual void updatePortalBrokerObject( DtBrokerObject* brokerObj,
            const T_PortalObject& sr );


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

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


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



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


         virtual const DtGlobalObjectDesignator& convertGlobalId( const DtString& id );

         virtual const DtString& convertGlobalId( const DtGlobalObjectDesignator& id );

         virtual bool isEntityIdentifierValid( const DtEntityIdentifier& entityId ) const;

         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;

      public:

         virtual T_PortalObject* translate( T_PortalObject* destination,
            const T_TenaObjectStateRepository& source,
            const T_TenaReflectedObject& refObj ) = 0;

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

      private:

         DtTenaObjectTranslator( const DtTenaObjectTranslator& other );

         DtTenaObjectTranslator& operator = ( const DtTenaObjectTranslator& other );

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

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

      protected:

         T_TenaReflectedObjectList* myTenaReflectedList;

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

         typedef std::map<const DtReflectedObject*,DtBrokerObject*> TenaToPortalReflectedMap;
         typedef std::map<const DtPortalReflectedObject*,DtBrokerObject*> PortalToTenaReflectedMap;

         TenaToPortalReflectedMap myPortalPublisherMap;
         PortalToTenaReflectedMap myTenaPublisherMap;

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

      };


      template <class PortalInterType,class TenaInterType>
      class DtTenaInteractionTranslator
         : public DtBaseInteractionTranslator<PortalInterType>
      {
      public:

         typedef DtTenaInteractionTranslator<PortalInterType,TenaInterType> ParentClass;

         typedef DtBaseInteractionTranslator<PortalInterType> BaseTranslatorClass;

      public:

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

         virtual ~DtTenaInteractionTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual DtTenaBroker* tenaBroker();
         virtual const DtTenaBroker* tenaBroker() const;

         virtual void shutdown();

      protected:


         virtual void initializeTenaCallbacks();
         virtual void removeTenaCallbacks();



         static void receiveTenaInteraction( TenaInterType* inter, void* usr );



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


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

         virtual TenaInterType* translate( TenaInterType* 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 const DtGlobalObjectDesignator& convertGlobalId( const DtString& id );

         virtual const DtString& convertGlobalId( const DtGlobalObjectDesignator& id );

         virtual void printDumpGuiToText( const PortalInterType& inter );
         virtual void printDumpGuiToText( const TenaInterType& inter );

      private:

         DtTenaInteractionTranslator( const DtTenaInteractionTranslator& other );

         DtTenaInteractionTranslator& operator = ( const DtTenaInteractionTranslator& other );

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

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

      };

   }
}

#define _tenaTranslator_INL_
#include <tenaBroker/tenaTranslator.inl>
#undef _tenaTranslator_INL_