rfxMessageFactory.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
//! \file rfxMessageFactory.h
//! \brief Defines a factory for creating and decoding RadarFX messages
//! \ingroup vreRadarFxShared
//!
//! This file contains the message factory for creating DtBaseMessage instances from
//! encoded byte arrays, supporting the serialization/deserialization system
 
#pragma once
 
#include "export.h"
 
#include <vector>
#include <map>
 
namespace makRadarFx
{
 
//! \brief Forward declaration of the base message class
class DtBaseMessage;
 
//! \brief Function pointer type for message decoder functions
//! \param bytes Pointer to the encoded byte array
//! \param length Length of the encoded byte array
//! \return Pointer to the newly created message instance
//!
//! This type defines the signature for message decoder functions that
//! convert encoded byte arrays back into message objects
typedef DtBaseMessage* (*Decoder)(unsigned char* bytes, int length);
 
//! \brief Factory for creating RadarFX message objects from encoded data
//!
//! This class manages the creation of message objects from encoded byte arrays.
//! It maintains a registry of message types and their corresponding decoder functions,
//! allowing the system to dynamically create the appropriate message object
//! based on the message type found in the encoded data.
class RFX_DLL_SHARED DtVreMessageFactory
{
public:
   //! \brief Constructor with initialization options
   //! \param initializeDefaults Whether to automatically register default message decoders
   //! \param isBigEndian Whether the encoded data is in big-endian format
   //!
   //! Creates a new message factory. If initializeDefaults is true, the factory
   //! will be automatically populated with decoders for all standard RadarFX messages.
   DtVreMessageFactory(bool initializeDefaults = true, bool isBigEndian = false);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up factory resources
   virtual ~DtVreMessageFactory();
 
   //! \brief Creates a message from encoded bytes
   //! \param bytes Pointer to the encoded byte array
   //! \param length Length of the encoded byte array
   //! \return Pointer to the newly created message instance, or nullptr on error
   //!
   //! Decodes the message type from the byte array and creates the appropriate
   //! message object. Returns nullptr if there is no decoder registered for the
   //! message type or if decoding fails.
   virtual DtBaseMessage* create(unsigned char* bytes, int length);
 
   //! \brief Creates a message from encoded bytes with known message type
   //! \param msgType The type of message to create
   //! \param bytes Pointer to the encoded byte array
   //! \param length Length of the encoded byte array
   //! \return Pointer to the newly created message instance, or nullptr on error
   //!
   //! Creates a message object for the specified message type. Returns nullptr
   //! if there is no decoder registered for the message type or if decoding fails.
   virtual DtBaseMessage* create(int msgType, unsigned char* bytes, int length);
 
   //! \brief Registers a message decoder function
   //! \param type Message type identifier
   //! \param decoder Function pointer to the decoder function
   //!
   //! Associates a message decoder function with a specific message type.
   //! The decoder will be used to create message objects of that type when
   //! decoding encoded data.
   virtual void registerCreator(unsigned int type, Decoder decoder);
 
   //! \brief Initializes the factory with decoders for standard message types
   //!
   //! Registers decoder functions for all the standard RadarFX message types.
   //! This is automatically called by the constructor if initializeDefaults is true.
   virtual void initializeDefaultMessages();
 
   //! \brief Clears all registered decoders
   //!
   //! Removes all decoder registrations from the factory, effectively
   //! resetting it to an empty state.
   virtual void clear();
 
protected:
   //! \brief Type definition for the map of message types to decoder functions
   typedef std::map<unsigned int, Decoder> DecoderMap;
 
   //! \brief Map of message types to their corresponding decoder functions
   DecoderMap myCreatorMap;
 
   //! \brief Flag indicating if the encoded data is in big-endian format
   bool myIsBigEndian;
};
 
} // namespace makRadarFx