rprTranslator.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 <rprBroker/dllExport.h>
#include <rprBroker/objectHeartbeater.h>

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

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

// All RPR 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 RPR Object class
// The reflected list of objects
// The state repository class of the RPR Object
// The publisher class of the RPR Object
#define RPR_TEMPLATE_LIST \
   template \
   < class T_PortalObject \
   , class T_PortalReflectedObject \
   , class T_RprReflectedObject \
   , class T_RprReflectedObjectList \
   , class T_RprObjectStateRepository \
   , class T_RprObjectPublisher>

#define RPR_TEMPLATE_FUNCTION \
   T_PortalObject, T_PortalReflectedObject, \
   T_RprReflectedObject, T_RprReflectedObjectList, \
   T_RprObjectStateRepository, T_RprObjectPublisher

#define DtVrxCATCH_AND_WARN( exception ) \
   catch ( exception ) \
   { \
      DtWarn << this->name() << " Translator caught " << #exception \
         << " when sending interaction." << std::endl; \
   }

class DtInteraction;
class DtReflectedObject;
class DtStateRepository;

namespace MAKVrExchange
{

   class DtRequestTranslationDiagnosticMessage;

   namespace DtRprBroker
   {

      class DtRprBroker;

      RPR_TEMPLATE_LIST
      class DtRprObjectTranslator
         : public DtBaseObjectTranslator<T_PortalObject,T_PortalReflectedObject>
      {
      public:

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

         typedef DtRprObjectTranslator<RPR_TEMPLATE_FUNCTION> ParentClass;

      public:

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

         virtual ~DtRprObjectTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual void forceUpdateAll();

         virtual void tick();

         virtual DtRprBroker* rprBroker();
         virtual const DtRprBroker* rprBroker() const;

         virtual void shutdown();

      protected:


         virtual void initializeRprCallbacks();
         virtual void removeRprCallbacks();



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

         static void rprObjectAddedCb( T_RprReflectedObject* refObj, void* usr );

         static void rprObjectUpdatedCb( T_RprReflectedObject* refObj, void* usr );

         static void rprObjectDeletedCb( T_RprReflectedObject* refObj, void* usr );



         virtual bool isPortalDiscoverable( const DtPortalReflectedObject* refObj );

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



         virtual bool isRprDiscoverable( const DtReflectedObject* refObj );



         virtual void discoverRprObject( T_RprReflectedObject& obj );
         virtual void discoverPortalObject( const T_PortalReflectedObject& obj );



         virtual void createRprPublisher( DtBrokerObject* brokerObj );

         virtual DtString rprObjectName( const T_PortalReflectedObject* refObj ) const;

         virtual T_RprObjectPublisher* instantiateRprPublisher(
            const T_PortalReflectedObject* refObj, const DtString& name );

         virtual void fillOutgoingIds( T_RprObjectPublisher* publisher,
            const DtString& name );

         virtual void createPortalPublisher( DtBrokerObject* brokerObj );



         virtual void receiveRprUpdate( T_RprReflectedObject& obj );
         virtual void receivePortalUpdate( const T_PortalReflectedObject& obj );



         virtual void updateRprBrokerObject( DtBrokerObject* brokerObj,
            const T_RprObjectStateRepository& sr );
         virtual void updatePortalBrokerObject( DtBrokerObject* brokerObj,
            const T_PortalObject& sr );

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

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



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



         virtual void deleteRprPublisher( 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 unsigned int numObjects() const;

      public:

         virtual T_PortalObject* translate( T_PortalObject* destination,
            const T_RprObjectStateRepository& source,
            const T_RprReflectedObject& refObj ) = 0;

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

      private:

         DtRprObjectTranslator( const DtRprObjectTranslator& other );

         DtRprObjectTranslator& operator = ( const DtRprObjectTranslator& other );

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

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

      protected:

         T_RprReflectedObjectList* myRprReflectedList;

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

         typedef std::map<const DtReflectedObject*,DtBrokerObject*> RprToPortalReflectedMap;
         typedef std::map<const DtPortalReflectedObject*,DtBrokerObject*> PortalToRprReflectedMap;

         RprToPortalReflectedMap myPortalPublisherMap;
         PortalToRprReflectedMap myRprPublisherMap;

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

         DtObjectHeartbeater myHeartbeater;

      };


      template <class PortalInterType,class RprInterType>
      class DtRprInteractionTranslator
         : public DtBaseInteractionTranslator<PortalInterType>
      {
      public:

         typedef DtRprInteractionTranslator<PortalInterType,RprInterType> ParentClass;

      public:

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

         virtual ~DtRprInteractionTranslator();

         virtual void enableReflectTranslator( bool enabled );

         virtual DtRprBroker* rprBroker();
         virtual const DtRprBroker* rprBroker() const;

         virtual void shutdown();

      protected:


         virtual void initializeRprCallbacks();
         virtual void removeRprCallbacks();



         static void receiveRprInteraction( RprInterType* inter, void* usr );



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


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

         virtual RprInterType* translate( RprInterType* 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;

      private:

         DtRprInteractionTranslator( const DtRprInteractionTranslator& other );

         DtRprInteractionTranslator& operator = ( const DtRprInteractionTranslator& other );

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

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

      };

   }
}

#define _rprTranslator_INL_
#include <rprBroker/rprTranslator.inl>
#undef _rprTranslator_INL_