radioProcessor.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2025 MAK Technologies
 * All rights reserved.
 *****************************************************************************/
 
//! \file radioProcessor.h
//! \ingroup vreMakRadio
//! \brief Provides radio communication processing components for VREngage
//!
//! This file defines the radio processor classes and factory components that
//! handle radio communications within VREngage simulations. It includes the
//! DtRadioProcessor which processes radio messages and manages radio state,
//! along with factory classes for creating specialized radio components.
 
#pragma once
 
#include <vreMakRadio/export.h>
#include <makRadioNet/radioNetManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
 
namespace makVrv
{
class DtBaseConnection;
}
 
namespace makRadio
{
class DtJammingSignalFilter;
}
 
class DtCommunicationManager;
 
namespace makVre
{
//! \brief Radio processor for handling radio communications in VREngage
//!
//! The DtRadioProcessor class manages radio communications for a specific connection,
//! processing incoming and outgoing radio messages and maintaining radio state.
//! It integrates with the radio network manager to provide seamless radio
//! communications within the simulation environment.
class DT_DLL_VREMAKRADIO DtRadioProcessor : public makVrv::DtVirtualBaseClass
{
public:
   //! \brief Constructor for the radio processor
   //! \param conn The protocol-specific base connection
   //! \param m The communication manager to use
   //!
   //! Creates a new radio processor for the specified connection and
   //! associates it with the given communication manager.
   DtRadioProcessor(makVrv::DtBaseConnection& conn, DtCommunicationManager* m);
 
   //! \brief Virtual destructor
   //!
   //! Properly cleans up resources used by the radio processor.
   virtual ~DtRadioProcessor() override;
 
   //! \brief Registers a processor instance with a specific connection
   //! \param conn The connection to register with
   //! \param instance The processor instance to register
   //!
   //! This static method registers a radio processor instance with a specific
   //! connection, allowing it to be found later using findInstance().
   static void registerInstance(makVrv::DtBaseConnection& conn, DtRadioProcessor* instance);
 
   //! \brief Unregisters a processor instance from a connection
   //! \param conn The connection to unregister from
   //!
   //! Removes any radio processor instance associated with the specified connection.
   static void unregisterInstance(makVrv::DtBaseConnection& conn);
 
   //! \brief Finds a registered processor instance for a connection
   //! \param conn The connection to find a processor for
   //! \return Pointer to the processor instance or nullptr if not found
   //!
   //! Looks up the radio processor instance associated with the specified connection.
   static DtRadioProcessor* findInstance(makVrv::DtBaseConnection& conn);
 
   //! \brief Gets the radio network manager associated with this processor
   //! \return Pointer to the radio network manager
   //!
   //! Returns the radio network manager that this processor uses for radio communications.
   makRadio::DtRadioNetManager* manager() { return myManager; }
 
protected:
   //! \brief Handles post-tick processing
   //!
   //! This method is called after each simulation tick to process radio communications.
   void handlePostTick();
 
protected:
   //! \brief Signal connection manager for handling event connections
   makVrv::DtSignalConnectionManager myConnections;
 
   //! \brief Pointer to the radio network manager
   makRadio::DtRadioNetManager* myManager;
};
 
//! \brief Factory class for creating radio processor instances
//!
//! This class serves as a factory for creating DtRadioProcessor instances.
//! Subclasses must implement the create() method to provide specific processor implementations.
class DT_DLL_VREMAKRADIO DtRadioProcessorCreator : public makVrv::DtVirtualBaseClass
{
public:
   //! \brief Constructor
   //! \param conn The connection the processor will use
   //!
   //! Creates a radio processor creator associated with the specified connection.
   DtRadioProcessorCreator(makVrv::DtBaseConnection& conn);
 
   //! \brief Gets the singleton creator instance for a connection
   //! \param conn The connection to get a creator for
   //! \return Reference to the creator instance
   //!
   //! Returns the singleton creator instance for the specified connection.
   static DtRadioProcessorCreator& instance(makVrv::DtBaseConnection& conn);
 
   //! \brief Registers a creator instance with a specific connection
   //! \param conn The connection to register with
   //! \param instance The creator instance to register
   //!
   //! This static method registers a creator instance with a specific connection.
   //! The creator must be registered with the same connection it was created with.
   static void registerInstance(makVrv::DtBaseConnection& conn, DtRadioProcessorCreator* instance);
 
   //! \brief Creates a new radio processor instance
   //! \param manager The communication manager to use with the processor
   //! \return Pointer to the newly created radio processor
   //!
   //! Creates a new radio processor instance using the specified communication manager.
   //! This is a virtual method that must be implemented by subclasses.
   virtual DtRadioProcessor* create(DtCommunicationManager* manager);
 
protected:
   //! \brief Reference to the connection this creator is associated with
   makVrv::DtBaseConnection& myVrlConn;
};
 
//! \brief Factory class for creating radio network manager instances
//!
//! This class serves as a factory for creating DtRadioNetManager instances.
//! Subclasses must implement the create() method to provide specific manager implementations.
class DT_DLL_VREMAKRADIO DtRadioNetManagerCreator : public makVrv::DtVirtualBaseClass
{
public:
   //! \brief Default constructor
   //!
   //! Creates a radio network manager creator.
   DtRadioNetManagerCreator();
 
   //! \brief Gets the singleton creator instance for a connection
   //! \param conn The connection to get a creator for
   //! \return Reference to the creator instance
   //!
   //! Returns the singleton creator instance for the specified connection.
   static DtRadioNetManagerCreator& instance(makVrv::DtBaseConnection& conn);
 
   //! \brief Registers a creator instance with a specific connection
   //! \param conn The connection to register with
   //! \param instance The creator instance to register
   //!
   //! This static method registers a creator instance with a specific connection.
   static void registerInstance(makVrv::DtBaseConnection& conn, DtRadioNetManagerCreator* instance);
 
   //! \brief Creates a new radio network manager instance
   //! \param manager The communication manager to use with the manager
   //! \return Pointer to the newly created radio network manager
   //!
   //! Creates a new radio network manager instance using the specified communication manager.
   //! This is a virtual method that must be implemented by subclasses.
   virtual makRadio::DtRadioNetManager* create(DtCommunicationManager* manager);
};
 
//! \brief Factory class for creating jamming signal filter instances
//!
//! This class serves as a factory for creating DtJammingSignalFilter instances.
//! Subclasses must implement the create() method to provide specific filter implementations.
class DT_DLL_VREMAKRADIO DtJammingSignalFilterCreator : public makVrv::DtVirtualBaseClass
{
public:
   //! \brief Default constructor
   //!
   //! Creates a jamming signal filter creator.
   DtJammingSignalFilterCreator();
 
   //! \brief Gets the singleton creator instance for a connection
   //! \param conn The connection to get a creator for
   //! \return Reference to the creator instance
   //!
   //! Returns the singleton creator instance for the specified connection.
   static DtJammingSignalFilterCreator& instance(makVrv::DtBaseConnection& conn);
 
   //! \brief Registers a creator instance with a specific connection
   //! \param conn The connection to register with
   //! \param instance The creator instance to register
   //!
   //! This static method registers a creator instance with a specific connection.
   static void registerInstance(makVrv::DtBaseConnection& conn, DtJammingSignalFilterCreator* instance);
 
   //! \brief Creates a new jamming signal filter instance
   //! \param manager The radio network manager to use with the filter
   //! \return Pointer to the newly created jamming signal filter
   //!
   //! Creates a new jamming signal filter instance using the specified radio network manager.
   //! This is a virtual method that must be implemented by subclasses.
   virtual makRadio::DtJammingSignalFilter* create(makRadio::DtRadioNetManager* manager);
};
} // namespace makVre