rfxMessage.h

Go to the documentation of this file.

// ******************************************************************************
// ** Copyright (c) 2025 MAK Technologies
// ** All rights reserved.
// ******************************************************************************
 
 
//! \file rfxMessage.h
//! \brief Defines the base message class for RadarFX client-server communication
//! \ingroup vreRadarFxShared
//!
//! This file contains the base message class used for all communications
//! between RadarFX clients and servers
 
 
#pragma once
 
#include "export.h"
#include "byteStream.h"
#include "rfxMessageTypes.h"
 
#include <string>
 
namespace makRadarFx
{
//! \brief Base class for all RadarFX messages
//!
//! This abstract base class defines the interface and common functionality
//! for all messages exchanged between RadarFX clients and servers. It provides
//! serialization/deserialization capabilities and handles message identification
//! through types, request IDs, and requester identification.
//!
//! All derived message classes must implement the clone() method and may override
//! the serialize() and deserialize() methods to add custom data fields.
class RFX_DLL_SHARED DtBaseMessage
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new message with default values for message type,
   //! requester ID, and request ID
   DtBaseMessage();
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of derived message classes
   virtual ~DtBaseMessage();
 
   //! \brief Gets the message type identifier
   //! \return Numeric identifier for the message type
   //!
   //! Returns the type identifier for this message, which is used for
   //! message routing and handling
   virtual unsigned int messageType() const;
 
   //! \brief Encodes the message into a byte array
   //! \return Pointer to the encoded byte array
   //!
   //! Converts the message into a byte array suitable for network transmission.
   //! The caller is responsible for calling delete[] on the returned byte array
   //! when it is no longer needed.
   virtual unsigned char* encode();
 
   //! \brief Decoding function prototype for derived classes
   //!
   //! Each derived message class should implement a static decode function:
   //! static DtDerivedMessage* decode(unsigned char* buffer, int length);
   //!
   //! This function creates a new message instance from the encoded byte array
   // static DtBaseMessage* decode(unsigned char* buffer, int length);
 
   //! \brief Gets the size of the encoded message in bytes
   //! \return Size of the message in bytes when encoded
   //!
   //! Calculates the total size required to encode this message
   virtual int messageSize();
 
   //! \brief Creates a deep copy of this message
   //! \return Pointer to a new instance that is a copy of this message
   //!
   //! Creates a new message instance that is an exact copy of this message.
   //! The caller is responsible for managing the memory of the returned object.
   //! This is a pure virtual method that must be implemented by all derived classes.
   virtual DtBaseMessage* clone() = 0;
 
   //! \brief Sets the requester identifier for this message
   //! \param requestor String identifier for the requester
   //!
   //! Sets the identifier of the entity sending this message. If left empty,
   //! the DtRadarFxConnector will automatically assign a requester ID when the
   //! message is sent using its requesterName() method.
   virtual void setRequestorId(const std::string& requestor);
 
   //! \brief Gets the requester identifier for this message
   //! \return String identifier of the requester
   //!
   //! Returns the identifier of the entity that sent this message
   virtual std::string requestorId();
 
   //! \brief Sets the request identifier for this message
   //! \param id Numeric identifier for the request
   //!
   //! Sets a unique identifier for this message request. If left at 0 (default),
   //! the DtRadarFxConnector will automatically assign a request ID when the
   //! message is sent using its nextId() method.
   virtual void setRequestId(int id);
 
   //! \brief Gets the request identifier for this message
   //! \return Numeric identifier of the request
   //!
   //! Returns the unique identifier for this message request
   virtual int requestId();
 
protected:
   //! \brief Serializes the message data to a stream writer
   //! \param writer Reference to the stream writer to write the data to
   //!
   //! Writes the message data to the provided stream writer. Derived classes
   //! should call the base class implementation before adding their own fields.
   virtual void serialize(DtStreamWriter& writer);
 
   //! \brief Deserializes message data from a stream reader
   //! \param reader Reference to the stream reader to read the data from
   //!
   //! Reads the message data from the provided stream reader. Derived classes
   //! should call the base class implementation before reading their own fields.
   virtual void deserialize(DtStreamReader& reader);
 
   //! \brief Message type identifier
   unsigned int myMessageType;
 
   //! \brief Identifier of the message sender
   std::string myRequestorId;
 
   //! \brief Unique identifier for this request
   int myRequestId;
};
} // namespace makRadarFx