rprTrans.h

Go to the documentation of this file.

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


#pragma once

#include "objectTrans.h"
#include "interactionTrans.h"

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

// All HLA 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 HLA Object class
// The reflected list of objects
// The state repository class of the HLA Object
// The publisher class of the HLA Object
#define HLA_TEMPLATE_LIST \
   template \
   < class T_PortalObject \
   , class T_PortalReflectedObject \
   , class T_HlaReflectedObject \
   , class T_HlaReflectedObjectList \
   , class T_HlaObjectStateRepository \
   , class T_HlaObjectPublisher>

#define HLA_TEMPLATE_FUNCTION \
   T_PortalObject, T_PortalReflectedObject, \
   T_HlaReflectedObject, T_HlaReflectedObjectList, \
   T_HlaObjectStateRepository, T_HlaObjectPublisher

namespace MAKVrExchange
{

   namespace DtRprBroker
   {

      HLA_TEMPLATE_LIST
      class DtRprObjectTranslator : public DtObjectTranslator
      {
      public:

         typedef DtRprObjectTranslator<HLA_TEMPLATE_FUNCTION> ParentClass;

      public:

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

         virtual ~DtRprObjectTranslator();

         virtual void enableTranslator( bool enabled );

         virtual void tick();

      protected:


         static bool hlaDiscoveryCriteria( DtReflectedObject* reflectedObj, void* usr );

         static void hlaObjectAddedCb( T_HlaReflectedObject* obj, void* usr );

         static void hlaObjectUpdatedCb( T_HlaReflectedObject* obj, void* usr );

         static void hlaObjectDeletedCb( T_HlaReflectedObject* obj, void* usr );



         static bool portalDiscoveryCriteria( const DtPortalReflectedObject* object, void* usr );

         static void portalObjectAddedCb( const T_PortalReflectedObject& obj, void* usr );

         static void portalObjectUpdatedCb( const T_PortalReflectedObject& obj, void* usr );

         static void portalObjectDeletedCb( const T_PortalReflectedObject& obj, void* usr );


         virtual bool isHlaPublishable( const DtBrokerObject* brokerObject ) const;

         virtual bool isPortalPublishable( const DtBrokerObject* brokerObject ) const;

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


         virtual void discoverHlaObject( T_HlaReflectedObject* obj );
         virtual void discoverPortalObject( const T_PortalReflectedObject& obj );



         virtual void createHlaPublisher( DtBrokerObject* brokerObject );
         virtual void createPortalPublisher( DtBrokerObject* brokerObject );


         virtual DtString hlaObjectName( const T_PortalReflectedObject* refObj );

         virtual T_HlaObjectPublisher* instantiateHlaPublisher(
            const T_PortalReflectedObject* refObj, const DtString& name );

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


         virtual void receiveHlaUpdate( T_HlaReflectedObject* obj );
         virtual void receivePortalUpdate( const T_PortalReflectedObject& obj );



         virtual void updateHlaBrokerObject( DtBrokerObject* brokerObj,
            const T_HlaObjectStateRepository& sr );
         virtual void updatePortalBrokerObject( DtBrokerObject* brokerObj,
            const T_PortalObject& sr );


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


         virtual void deleteHlaPublisher( DtBrokerObject* brokerObject );
         virtual void deletePortalPublisher( DtBrokerObject* brokerObject );


      public:

         virtual T_PortalObject* translate( T_PortalObject* destination,
            const T_HlaObjectStateRepository& source,
            const T_HlaReflectedObject& reflectedObject ) = 0;

         virtual T_HlaObjectStateRepository* translate(
            T_HlaObjectStateRepository* destination, const T_PortalObject& source,
            const T_PortalReflectedObject& reflectedObject ) = 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_HlaReflectedObjectList* myHlaReflectedList;
         DtPortalReflectedObjectManager<T_PortalReflectedObject>* myPortalReflectedManager;

      };




      // All HLA Translators must have the following template arguments:
      // The Portal Interaction class the message translates
      // The HLA Interaction class
      template <class PortalInterType, class HlaInterType>
      class DtRprInteractionTranslator : public DtInteractionTranslator
      {
      public:

         typedef DtRprInteractionTranslator<PortalInterType,HlaInterType> ParentClass;

      public:

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

         virtual ~DtRprInteractionTranslator();

         virtual void enableTranslator( bool enabled );

      protected:


         static void receiveHlaInteraction( HlaInterType* inter, void* usr );
         static void receivePortalInteraction( const PortalInterType& inter, void* usr );



         virtual void createHlaInteraction( const PortalInterType& inter );
         virtual void createPortalInteraction( const HlaInterType& inter );

      public:

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

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

      private:

         DtRprInteractionTranslator( const DtRprInteractionTranslator& other );

         DtRprInteractionTranslator& operator = ( const DtRprInteractionTranslator& other );

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

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

      };

   }
}

#define hlaTranslator_INL_
#include "rprTrans.inl"
#undef hlaTranslator_INL_