ifVreSensorDataRequest.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file ifVreSensorDataRequest.h
//! \ingroup vreVrfMessages
//! \brief Interface message class for requesting VREngage sensor data
//!
//! This file defines the DtIfVreSensorDataRequest class, which is used to
//! request sensor data from various sensor types in the VREngage simulation.
//! It supports one-time requests, subscription, and unsubscription operations.
 
//! The DtIfVreSensorDataRequest class provides a mechanism for requesting
//! sensor data from sensor objects in the simulation system.
 
#pragma once
 
#include <vreVrfMessages/export.h>
#include <vrfExtProtocol/simInterfaceContent.h>
#include <vrfutil/rwUUID.h>
#include <vlutil/vlString.h>
 
//! \brief Interface message for requesting sensor data
//!
//! This class is used to request sensor data messages to be sent from a DtObjectSensor.
//! It supports three types of requests: one-time updates, subscriptions for continuous
//! updates, and unsubscribe operations to cancel existing subscriptions.
class VRFMESSAGES_DLL DtIfVreSensorDataRequest : public DtSimInterfaceContent
{
public:
   //! \brief Enumeration of available request types
   enum RequestType
   {
      ONE_UPDATE, //!< Request a single update of sensor data
      SUBSCRIBE,  //!< Subscribe to receive continuous sensor data updates
      UNSUBSCRIBE //!< Cancel an existing subscription
   };
 
   //! \brief Default constructor
   //!
   //! Initializes an empty sensor data request message.
   DtIfVreSensorDataRequest();
 
   //! \brief Copy constructor
   //! \param orig The sensor data request to copy from
   //!
   //! Creates a new sensor data request message by copying an existing one.
   DtIfVreSensorDataRequest(const DtIfVreSensorDataRequest& orig);
 
   //! \brief Assignment operator
   //! \param orig The sensor data request to copy from
   //! \return Reference to this object after assignment
   //!
   //! Copies the contents of another sensor data request message into this one.
   const DtIfVreSensorDataRequest& operator=(const DtIfVreSensorDataRequest& orig);
 
   //! \brief Virtual destructor
   virtual ~DtIfVreSensorDataRequest() override;
 
   //! \brief Gets the interface message type
   //! \return The message type identifier
   //!
   //! Returns DtVreSensorDataRequestMessageType as defined in vreVrfMessageTypes.h.
   virtual int type() const override;
 
   //! \brief Creates a copy of this message
   //! \return Pointer to the new copy
   //!
   //! Creates a dynamically allocated copy of this message.
   virtual DtSimInterfaceContent* clone() const override;
 
   //! \brief Sets the UUID of the entity whose sensor data is being requested
   //! \param uuid The entity UUID to set
   //!
   //! Sets the UUID of the entity whose sensor data is being requested.
   //! This identifies the specific entity in the simulation that has the sensor.
   virtual void setUUID(const DtUUID& uuid);
 
   //! \brief Gets the UUID of the entity whose sensor data is being requested
   //! \return The entity UUID
   virtual const DtUUID& uuid() const;
 
   //! \brief Sets the sensor type
   //! \param type The sensor type identifier
   //!
   //! Sets the type of sensor for which data is being requested.
   //! Sensor types are defined in the system and determine what kind of
   //! sensor data will be provided in response.
   virtual void setSensorType(const int type);
 
   //! \brief Gets the sensor type
   //! \return The sensor type identifier
   virtual int sensorType() const;
 
   //! \brief Sets the subscriber identifier
   //! \param id The subscriber identifier
   //!
   //! Sets the unique identifier for the subscriber requesting the data.
   //! This is used to manage multiple subscriptions and route responses.
   virtual void setSubscriberId(const unsigned long id);
 
   //! \brief Gets the subscriber identifier
   //! \return The subscriber identifier
   virtual unsigned long subscriberId() const;
 
   //! \brief Sets the request type
   //! \param type The request type (ONE_UPDATE, SUBSCRIBE, or UNSUBSCRIBE)
   //!
   //! Sets the type of request being made. This determines how the sensor
   //! system will handle the request (single update vs. continuous updates).
   virtual void setRequestType(const RequestType type);
 
   //! \brief Gets the request type
   //! \return The request type (ONE_UPDATE, SUBSCRIBE, or UNSUBSCRIBE)
   virtual RequestType requestType() const;
 
   //! \brief Gets the network representation size
   //! \return Size in bytes of the network representation
   //!
   //! Returns the size of the network buffer needed to store this message.
   virtual int netRepSize() const override;
 
   //! \brief Deserializes the message from a network buffer
   //! \param contentBuffer Pointer to the network buffer
   //! \param contentSize Size of the buffer in bytes
   //! \return True if deserialization was successful
   //!
   //! Fills the message from the provided network buffer.
   virtual bool setFromNet(const char* contentBuffer, unsigned contentSize) override;
 
   //! \brief Serializes the message for network transmission
   //! \return True if serialization was successful
   //!
   //! Prepares the message for network transmission.
   virtual bool setToNet() override;
 
   //! \brief Formats the message data as a string
   //! \param str String to store the formatted message data
   //!
   //! Appends a human-readable representation of the message to the provided string.
   virtual void printDataToString(DtString& str) override;
 
   //! \brief Static creator function for factory registration
   //! \return Pointer to a new instance of DtIfVreSensorDataRequest
   //!
   //! This static function is used for registration with DtInterfaceContentFactory.
   static DtSimInterfaceContent* creator();
 
protected:
   //! \brief UUID of the entity whose sensor data is being requested
   DtUUID myUUID;
 
   //! \brief Type of sensor for which data is being requested
   DtU32 mySensorType;
 
   //! \brief Unique identifier for the subscriber requesting the data
   DtU64 mySubscriberId;
 
   //! \brief Type of request (ONE_UPDATE, SUBSCRIBE, or UNSUBSCRIBE)
   DtU32 myRequestType;
};