udpNetworkForwarder.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file udpNetworkForwarder.h
//! \brief Defines UDP-based network forwarder for VREngage messages
//!
//! This file contains the DtUdpNetworkForwarder class which implements message
//! forwarding through UDP sockets. It extends the DtNetworkForwarder base class
//! to provide UDP-specific network communication for distributing VREngage messages
//! across networks, handling both message sending and receiving.
 
#pragma once
 
#include "vreMessageManager/export.h"
#include "vreMessageManager/networkForwarder.h"
#include "vreMessageManager/vreMessageListenerTree.h"
 
#include <vlutil/vlInetUdpSocket.h>
 
#include <string>
 
namespace makVre
{
 
class DtVreMessageFactory;
 
//! \brief UDP-based implementation of network forwarder for VREngage messages
//!
//! This class implements a network forwarder that uses UDP sockets to send and
//! receive VREngage messages over the network. It manages a UDP socket bound to
//! a specific device and port, sending messages to a configured destination address.
//! The forwarder receives incoming messages, processes them, and forwards them to
//! the message manager for handling.
class MESSAGEMANAGER_DLL DtUdpNetworkForwarder : public DtNetworkForwarder
{
public:
   //! \brief Constructor
   //! \param factory Pointer to the message factory for creating messages from raw data
   //! \param deviceAddress Network interface address to bind to (e.g., "0.0.0.0" for all interfaces)
   //! \param destinationAddress Destination address for outgoing messages (can be multicast/broadcast)
   //! \param port UDP port number for both sending and receiving
   //!
   //! Initializes a new UDP network forwarder with the specified message factory and
   //! network parameters. The forwarder binds to the specified device address and port
   //! for receiving messages and sends messages to the specified destination address.
   DtUdpNetworkForwarder(
      DtVreMessageFactory* factory, std::string deviceAddress, std::string destinationAddress, int port);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources, including the UDP socket if it exists.
   virtual ~DtUdpNetworkForwarder() override;
 
   //! \brief Flushes bundled messages to the network via UDP
   //!
   //! This method sends all accumulated message bundles to the network through
   //! the UDP socket. It checks that the socket is valid and operational before
   //! sending. Each bundle with content is sent as a single UDP packet to the
   //! configured destination address and port.
   //!
   //! Implements the pure virtual method from DtNetworkForwarder.
   virtual void flush() override;
 
   //! \brief Enables the UDP network forwarder
   //! \return True if the forwarder was successfully enabled, false otherwise
   //!
   //! This method enables the UDP network forwarder by creating and configuring
   //! the UDP socket. It configures the socket with the specified device address,
   //! destination address, and port. The socket is set to non-blocking mode and
   //! opened for communication. If the socket cannot be opened, the method returns false.
   //!
   //! Overrides the base class implementation to add UDP-specific initialization.
   virtual bool enable() override;
 
   //! \brief Disables the UDP network forwarder
   //!
   //! This method disables the UDP network forwarder by closing and deleting
   //! the UDP socket. After this method is called, no more messages will be
   //! sent or received until enable() is called again.
   //!
   //! Overrides the base class implementation to add UDP-specific cleanup.
   virtual void disable() override;
 
   //! \brief Processes incoming UDP messages
   //! \param dt Delta time in seconds since the last tick (not used)
   //!
   //! This method polls the UDP socket for incoming messages, processes them, and
   //! forwards them to the message manager. It continues reading from the socket
   //! until there are no more messages available or an error occurs. If the socket
   //! becomes invalid, it is closed and deleted.
   //!
   //! This method should be called regularly (e.g., once per frame) to ensure
   //! timely processing of incoming messages.
   virtual void tick(double dt);
 
protected:
   //! \brief Processes a received UDP packet containing VREngage messages
   //! \param buffer Pointer to the buffer containing the received data
   //! \param length Length of the received data in bytes
   //! \param from Endpoint information about the sender
   //!
   //! This method extracts VREngage messages from a received UDP packet and
   //! queues them for processing by the message manager. It iterates through
   //! the buffer, creating messages using the message factory, and filtering out
   //! messages that originated from this forwarder to prevent loops.
   virtual void handleBuffer(char* buffer, int length, DtInetEndpoint& from);
 
   //! \brief Network interface address to bind to
   //!
   //! This is the address of the network interface on which the UDP socket
   //! will listen for incoming messages (e.g., "0.0.0.0" for all interfaces).
   std::string myDeviceAddress;
 
   //! \brief Destination address for outgoing messages
   //!
   //! This is the address to which outgoing messages will be sent.
   //! It can be a multicast or broadcast address to reach multiple receivers.
   std::string myDestinationAddress;
 
   //! \brief UDP port number for both sending and receiving
   int myPort;
 
   //! \brief Pointer to the UDP socket used for communication
   //!
   //! This socket is created in enable() and destroyed in disable().
   //! It is used for both sending outgoing messages and receiving incoming messages.
   DtInetUdpSocket* mySocket;
};
 
} // namespace makVre