exerciseConnNetForwarder.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file exerciseConnNetForwarder.h
//! \brief Defines a network forwarder for VREngage messages using exercise connections
//!
//! This file contains the DtExerciseConnNetworkForwarder class which implements
//! message forwarding through an exercise connection using the communication manager.
//! It handles bundling of outgoing messages for efficiency and processes incoming
//! data events from the network, enabling distributed communication between VREngage
//! components across a network.
 
#pragma once
 
#include "vreMessageManager/export.h"
#include "vreMessageManager/networkForwarder.h"
#include "vreMessageManager/vreMessage.h"
 
#include <boost/signals2.hpp>
 
class DtCommunicationManager;
 
namespace makVrfEvents
{
class DtEvent;
}
 
namespace makVre
{
//! \brief Parameter ID used to identify VREngage messages in data events
//!
//! This constant is used to filter data events that contain VREngage messages
//! when receiving network traffic through the exercise connection.
const int DtVrEngageDatumParamId = 2000000;
 
class DtVreMessageFactory;
 
//! \brief Network forwarder that uses an exercise connection to send and receive VREngage messages
//!
//! This class implements a network forwarder that uses the exercise connection
//! (via a communication manager) to send and receive VREngage messages over the network.
//! It bundles outgoing messages for efficient transmission and processes incoming
//! data events from the network. The forwarder ensures messages are only processed once
//! by tracking the originating application ID of each message.
class MESSAGEMANAGER_DLL DtExerciseConnNetworkForwarder : public DtNetworkForwarder
{
public:
   //! \brief Constructor
   //! \param factory Pointer to the message factory for creating messages from raw data
   //! \param exerciseConn Pointer to the communication manager for the exercise connection
   //!
   //! Initializes a new exercise connection network forwarder with the specified
   //! message factory and communication manager. The message factory is used to
   //! create messages from incoming raw data, and the communication manager is used
   //! to send outgoing messages through the exercise connection.
   DtExerciseConnNetworkForwarder(makVre::DtVreMessageFactory* factory, DtCommunicationManager* exerciseConn);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources, including any remaining message bundles.
   virtual ~DtExerciseConnNetworkForwarder() override;
 
   //! \brief Flushes bundled messages to the network
   //!
   //! This method sends all accumulated message bundles to the network through
   //! the exercise connection. Because messages are bundled for efficiency, this
   //! method should be called once per frame to ensure timely delivery of messages.
   //! After sending, each bundle is reset for reuse in the next frame.
   //!
   //! \note This must be called once per frame to ensure messages are transmitted
   virtual void flush() override;
 
   //! \brief Enables the network forwarder
   //! \return True if the forwarder was successfully enabled
   //!
   //! This method enables the network forwarder by connecting to the data event
   //! signal of the communication manager's event manager. When enabled, the
   //! forwarder will process incoming data events and forward outgoing messages.
   virtual bool enable() override;
 
   //! \brief Disables the network forwarder
   //!
   //! This method disables the network forwarder by disconnecting from the data
   //! event signal. When disabled, the forwarder will not process incoming data
   //! events or forward outgoing messages.
   virtual void disable() override;
 
protected:
   //! \brief Handles incoming data events from the exercise connection
   //! \param data Reference to the received data event
   //!
   //! This method processes incoming data events from the exercise connection.
   //! If the event contains VREngage messages (identified by DtVrEngageDatumParamId),
   //! it extracts the messages from the data buffer and queues them for processing
   //! by the message manager, excluding any messages that originated from this
   //! application instance to prevent loops.
   virtual void handleDataInteraction(const makVrfEvents::DtEvent& data);
 
   //! \brief Sends a message through the network
   //! \param msg Pointer to the message to send
   //! \return Message processing result (HANDLED or NOT_HANDLED)
   //!
   //! This method bundles the message for efficient network transmission. If the
   //! message was not previously forwarded (originatingApplicationId is 0), it is
   //! added to an appropriate message bundle and tagged with this forwarder's ID.
   //! The actual transmission occurs when flush() is called.
   virtual makVre::DtVreMessageResult netSendMessage(makVre::DtVreMessage* msg) override;
 
   //! \brief Pointer to the communication manager for the exercise connection
   //!
   //! This communication manager is used to send outgoing messages through the
   //! exercise connection and to receive incoming data events.
   DtCommunicationManager* myCommunicationManager;
 
   //! \brief Connection to the data event signal
   //!
   //! This connection is used to receive data events from the communication
   //! manager's event manager. It is established in enable() and terminated
   //! in disable().
   boost::signals2::scoped_connection myDataInteractionConnection;
};
 
} // namespace makVre