ddsTrans.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2015 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 <ddsBroker/dllExport.h>

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

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

#include <vlOpenSplice/simpleOM.h>

#include <vlutil/vlString.h>

// ************************************************************************ //
// Use the DIS implementation from VR-Link by temporarily defining DtDIS.
// ************************************************************************ //
#ifndef DtDIS
#  define MUST_UNDEF_DTDIS
#  define DtDIS 1
#endif

#include <vl/globalObjectDesignator.h>

#ifdef MUST_UNDEF_DTDIS
#  undef DtDIS
#endif
// ************************************************************************ //

#define DDS_TEMPLATE_LIST \
   template \
   < class T_PortalObject \
   , class T_PortalReflectedObject \
   , class T_DdsReflectedObject \
   , class T_DdsObjectStateRepository \
   , class T_DdsObjectPublisher>

#define DDS_TEMPLATE_FUNCTION \
   T_PortalObject, T_PortalReflectedObject, \
   T_DdsReflectedObject, T_DdsObjectStateRepository, \
   T_DdsObjectPublisher

class DtInteraction;
class DtObjectPublisher;
class DtStateRepository;

namespace MAKVrExchange
{

   class DtRequestTranslationDiagnosticMessage;

   namespace DtDdsBroker
   {

      class DtDdsBroker;
      class DtReflectedObject;

      DDS_TEMPLATE_LIST
      class DtDdsObjectTranslator
         : public DtBaseObjectTranslator<T_PortalObject,T_PortalReflectedObject>
      {
      public:

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

         typedef DtDdsObjectTranslator<DDS_TEMPLATE_FUNCTION> ParentClass;

         typedef DtBaseObjectTranslator<T_PortalObject,T_PortalReflectedObject> BaseTranslatorClass;

      public:

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

         virtual ~DtDdsObjectTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual void forceUpdateAll();

         virtual void tick();

         virtual DtDdsBroker* ddsBroker();
         virtual const DtDdsBroker* ddsBroker() const;

         virtual void shutdown();

      protected:


         virtual void initializeDdsCallbacks();
         virtual void removeDdsCallbacks();



         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* releaseBrokerObject( const DtReflectedObject* refObj );
         virtual DtBrokerObject* releaseBrokerObject( const DtPortalReflectedObject* refObj );



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

         static void ddsObjectAddedCb( void* refObj, void* usr );

         static void ddsObjectUpdatedCb( void* refObj, void* usr );

         static void ddsObjectDeletedCb( void* refObj, void* usr );



         virtual bool isPortalDiscoverable( const DtPortalReflectedObject* refObj );

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



         virtual bool isDdsDiscoverable( const T_DdsReflectedObject* reflectedObj );



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



         virtual void discoverDdsObject( T_DdsReflectedObject& refObj );
         virtual void discoverPortalObject( const T_PortalReflectedObject& refObj );



         virtual void createDdsPublisher( DtBrokerObject* brokerObj );

         virtual DtString ddsObjectName( const T_PortalReflectedObject* refObj ) const;

         virtual T_DdsObjectPublisher* instantiateDdsPublisher(
            const T_PortalReflectedObject* refObj, const DtString& name );

         virtual bool performDdsGlobalIdMapping( const T_DdsObjectPublisher* publisher,
            const T_PortalReflectedObject& refObj );

         virtual void createPortalPublisher( DtBrokerObject* brokerObj );

         virtual DtString portalObjectName( const T_DdsReflectedObject* refObj ) const;

         virtual bool performPortalGlobalIdMapping(
            const DtPortalObjectPublisherTemplate<T_PortalObject>* publisher,
            const T_DdsReflectedObject& refObj );



         virtual void receiveDdsUpdate( T_DdsReflectedObject& obj );
         virtual void receivePortalUpdate( const T_PortalReflectedObject& obj );



         virtual void updateDdsBrokerObject( DtBrokerObject* brokerObj,
            const T_DdsObjectStateRepository& sr );
         virtual void updatePortalBrokerObject( DtBrokerObject* brokerObj,
            const T_PortalObject& sr );


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

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


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



         virtual void deleteDdsPublisher( 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 T_PortalObject& incoming, const T_DdsObjectStateRepository& outgoing ) const;

         virtual void printIncomingOutgoingStateReps(
            const T_DdsObjectStateRepository& incoming, const T_PortalObject& outgoing ) const;

         virtual void performPortalDebugging( const T_PortalObject& incoming,
            const T_DdsObjectStateRepository& outgoing );

         virtual void performPortalDebugging( const T_DdsObjectStateRepository& incoming,
            const T_PortalObject& 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_DdsObjectStateRepository& source,
            const T_DdsReflectedObject& refObj ) = 0;

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

      private:

         DtDdsObjectTranslator( const DtDdsObjectTranslator& other );

         DtDdsObjectTranslator& operator = ( const DtDdsObjectTranslator& other );

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

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

      protected:

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

         typedef std::map<const DtReflectedObject*,DtBrokerObject*> DdsToPortalReflectedMap;
         typedef std::map<const DtPortalReflectedObject*,DtBrokerObject*> PortalToDdsReflectedMap;

         DdsToPortalReflectedMap myPortalPublisherMap;
         PortalToDdsReflectedMap myDdsPublisherMap;

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

      };


      template <typename T_PortalInteraction,typename T_DDSInteraction>
      class DtDdsInteractionTranslator
         : public DtBaseInteractionTranslator<T_PortalInteraction>
      {
      public:

         typedef DtDdsInteractionTranslator<T_PortalInteraction,T_DDSInteraction> ParentClass;

      public:

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

         virtual ~DtDdsInteractionTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual DtDdsBroker* ddsBroker();
         virtual const DtDdsBroker* ddsBroker() const;

         virtual void shutdown();

      protected:


         virtual void initializeDdsCallbacks();
         virtual void removeDdsCallbacks();



         static void receiveDdsInteraction( void* interaction, void* userData );



         virtual void createInteraction( const T_PortalInteraction& incoming );
         virtual void createPortalInteraction( const T_DDSInteraction& incoming );



         virtual T_PortalInteraction* translate( T_PortalInteraction* destination,
            const T_DDSInteraction& source ) = 0;

         virtual T_DDSInteraction* translate( T_DDSInteraction* destination,
            const T_PortalInteraction& source ) = 0;

         virtual void printIncomingOutgoingInteractions( const T_PortalInteraction& incoming,
            const T_DDSInteraction& outgoing ) const;

         virtual void printIncomingOutgoingInteractions( const T_DDSInteraction& incoming,
            const T_PortalInteraction& outgoing ) const;

         virtual void printDumpGuiToText( const DtString& protocol, const DtString& description ) const;

         virtual void printDDSInteraction( const T_DDSInteraction& inter ) const = 0;

      private:

         DtDdsInteractionTranslator( const DtDdsInteractionTranslator& other );

         DtDdsInteractionTranslator& operator = ( const DtDdsInteractionTranslator& other );

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

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

      };

   }
}

#include <ddsBroker/ddsTrans.inl>