ddsDomainConnection.h

Go to the documentation of this file.

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


#pragma once

#include <vlDds/dllExport.h>

#include <vlDds/ddsCallbackInfo.h>
#include <vlDds/ddsUtils.h>
#include <matrix/vlTaitBryan.h>
#include <matrix/vlVector.h>
#include <vlutil/vlString.h>
#include <vlutil/vlTime.h>

#include <vector>
#include <map>

#ifdef DtDDS_RTI
#include <vlDds/ccpp_simpleOM.h>
#include "ndds/ndds_cpp.h"
#else
#include <dds_dcps.h>
#include <ccpp_WaitSet.h>
#include <vlDds/simpleOM.h>
#include <ccpp_DomainParticipantFactory.h>
#include <vlDds/simpleOMDcps_impl.h>
#endif

class DtEntityStateRepository;

namespace MAKVrExchange
{

   namespace DtDdsBroker
   {

      class DtReflectedEntity;
      class DtDdsDomainConnInitializer;

      class DT_DLL_VLDDS DtDdsDomainConnection
      {
      public:

         typedef std::map<DtString,DtReflectedEntity*> DtReflectedEntityList;

      public:

         DtDdsDomainConnection( const DtDdsDomainConnInitializer& init );

         virtual ~DtDdsDomainConnection();

         virtual void drainInput( DtTime timeout = -1 );

         virtual void send( const DtEntityStateRepository& entity );
         virtual void send( simpleOM::simpleFireInteraction& fireInter );
         virtual void send( simpleOM::simpleDetonationInteraction& detInter );

         virtual void sendFinal( const DtEntityStateRepository& entity );

         virtual DtClock* clock();

         virtual void addEntityAdditionCallback(
            DtDdsCallbackFunction cb, void* userData );
         virtual void removeEntityAdditionCallback(
            DtDdsCallbackFunction cb, void* userData );

         virtual void addEntityRemovalCallback(
            DtDdsCallbackFunction cb, void* userData );
         virtual void removeEntityRemovalCallback(
            DtDdsCallbackFunction cb, void* userData );

         virtual void addDetonationCallback(
            DtDdsCallbackFunction cb, void* userData );
         virtual void removeDetonationCallback(
            DtDdsCallbackFunction cb, void* userData );

         virtual void addWeaponFireCallback(
            DtDdsCallbackFunction cb, void* userData );
         virtual void removeWeaponFireCallback(
            DtDdsCallbackFunction cb, void* userData );

         DtReflectedEntityList& reflectedEntities();
         DtReflectedEntityList& publishedEntities();

      protected:

         template <typename ReaderType>
         unsigned int readAndProcess( ReaderType* reader );

         virtual bool encodeEntityState( const DtEntityStateRepository& esr,
            simpleOM::simpleBaseEntity& instanceData );
         virtual bool decodeEntityState( const simpleOM::simpleBaseEntity& instanceData,
            DtEntityStateRepository* esr );

         virtual DtReflectedEntity* addReflectedObject( const char* id );
         virtual void removeReflectedObject( const char* id );

      protected:

         DtString myPartitionName;
         DtClock* myClock;
         
#ifdef DtDDS_RTI
         typedef std::map<DDS_Condition*,DDS_DataReader*> DataReaderMap;
         
         // DDS objects
         DDS_DomainId_t myDomain;
         //DDS_DomainParticipantFactory_ptr myDomParticipantFactory;
         DDSDomainParticipantFactory* myDomParticipantFactory;
         DDSDomainParticipant* myDomParticipant;
         DDSPublisher* myPub;
         DDSSubscriber* mySub;
         DDS_PublisherQos myPubQos;
         DDS_SubscriberQos mySubQos;
         //DDS_SampleInfoSeq_var myInfoList;
         DDS_SampleInfoSeq myInfoList;
         DDSWaitSet* myWaitSet;

         // Application-specific simpleOM objects
         simpleOM::simpleBaseEntityTypeSupport* myBaseTopicDataType;
         simpleOM::simpleBaseEntityDataReader* myBaseEntityReader;
         simpleOM::simpleBaseEntityDataWriter* myBaseEntityWriter;
         DDSStatusCondition* myBaseEntityStatusCond;
         DDSTopic* myBaseTopic;

         simpleOM::simpleDetonationInteractionTypeSupport* myDetTopicDataType;
         simpleOM::simpleDetonationInteractionDataReader* myDetReader;
         simpleOM::simpleDetonationInteractionDataWriter* myDetWriter;
         DDSStatusCondition* myDetStatusCond;
         DDSTopic* myDetTopic;

         simpleOM::simpleFireInteractionTypeSupport* myFireTopicDataType;
         simpleOM::simpleFireInteractionDataReader* myFireReader;
         simpleOM::simpleFireInteractionDataWriter* myFireWriter;
         DDSStatusCondition* myFireStatusCond;
         DDSTopic* myFireTopic;
         
         typedef std::pair<simpleOM::simpleBaseEntity*,DDS_InstanceHandle_t> InstanceHandlePair;
#elif DtDDS_OPENSPLICE
         typedef std::map<DDS::Condition*,DDS::DataReader*> DataReaderMap;

         // DDS objects
         DDS::DomainId_t myDomain;
         DDS::DomainParticipantFactory_ptr myDomParticipantFactory;
         DDS::DomainParticipant_ptr myDomParticipant;
         DDS::Publisher_ptr myPub;
         DDS::Subscriber_ptr mySub;
         DDS::PublisherQos myPubQos;
         DDS::SubscriberQos mySubQos;
         DDS::SampleInfoSeq_var myInfoList;
         DDS::WaitSet myWaitSet;

         // Application-specific simpleOM objects
         simpleOM::simpleBaseEntityTypeSupport myBaseTopicDataType;
         simpleOM::simpleBaseEntityDataReader_ptr myBaseEntityReader;
         simpleOM::simpleBaseEntityDataWriter_ptr myBaseEntityWriter;
         DDS::StatusCondition_ptr myBaseEntityStatusCond;
         DDS::Topic_ptr myBaseTopic;

         simpleOM::simpleDetonationInteractionTypeSupport myDetTopicDataType;
         simpleOM::simpleDetonationInteractionDataReader_ptr myDetReader;
         simpleOM::simpleDetonationInteractionDataWriter_ptr myDetWriter;
         DDS::StatusCondition_ptr myDetStatusCond;
         DDS::Topic_ptr myDetTopic;

         simpleOM::simpleFireInteractionTypeSupport myFireTopicDataType;
         simpleOM::simpleFireInteractionDataReader_ptr myFireReader;
         simpleOM::simpleFireInteractionDataWriter_ptr myFireWriter;
         DDS::StatusCondition_ptr myFireStatusCond;
         DDS::Topic_ptr myFireTopic;

         typedef std::pair<simpleOM::simpleBaseEntity*,DDS::InstanceHandle_t> InstanceHandlePair;
#endif
         DataReaderMap myDataReaders;
         unsigned int myMostRecentlyCheckedCondition;

         DtReflectedEntityList myReflectedEntityList;
         DtReflectedEntityList myPublishedEntityList;
         
         typedef std::map<const DtEntityStateRepository*,InstanceHandlePair> EntityInstanceMap;
         EntityInstanceMap myEntityInstanceMap;

         typedef std::vector<DtDdsCbInfo*> DdsCallbackList;
         DdsCallbackList myObjectAdditionCallbacks;
         DdsCallbackList myObjectRemovalCallbacks;
         DdsCallbackList myDetonationCallbacks;
         DdsCallbackList myWeaponFireCallbacks;

      };

   }
}