vortexConfiguration.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexConfiguration.h
//! \brief   Provides configuration management for Vortex physics parameters
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include "vreVrfVortexObjparam/vortexConfigurationDescriptor.h"
 
#include <VxSim/VxSmartInterface.h>
#include <VxSim/VxVHLInterface.h>
 
#include <vector>
 
class DtVrfObjectStateRepository;
 
namespace VxData
{
class FieldBase;
}
 
namespace VxSim
{
class VxExtension;
class VxPluginExtension;
class VxVHLInterface;
class VxSimulationState;
} // namespace VxSim
 
namespace makVre
{
//! \brief Base class for Vortex configuration elements
//!
//! Provides common functionality for storing and managing Vortex
//! configuration parameters regardless of their data type.
class VREVRFVORTEX_DLL DtVortexConfigurationBaseElement
{
public:
   //! \brief Constructor with field initialization
   //!
   //! Creates a configuration element associated with the specified Vortex field.
   //!
   //! \param field Pointer to the Vortex field to be configured
   explicit DtVortexConfigurationBaseElement(VxData::FieldBase* field);
 
   //! \brief Virtual destructor
   //!
   //! Allows for proper cleanup of derived classes.
   virtual ~DtVortexConfigurationBaseElement();
 
   //! \brief Gets the associated Vortex field
   //!
   //! \return Pointer to the Vortex field being configured
   virtual VxData::FieldBase* getField();
 
   //! \brief Sets the associated Vortex field
   //!
   //! \param fb Pointer to the Vortex field to be configured
   virtual void setField(VxData::FieldBase* fb);
 
   //! \brief Gets the Vortex identifier
   //!
   //! \return The Vortex ID of the configured field
   virtual const Vx::VxID& vxId();
 
   //! \brief Sets the Vortex identifier
   //!
   //! \param vortexId The Vortex ID to associate with this element
   virtual void setVxId(const Vx::VxID& vortexId);
 
   //! \brief Updates the configuration value in Vortex
   //!
   //! Pure virtual function that must be implemented by derived classes
   //! to update the Vortex field with the stored value.
   //!
   //! \return True if the update succeeded, false otherwise
   virtual bool updateConfigValue() = 0;
 
protected:
   VxData::FieldBase* myVortexField; //!< Pointer to the Vortex field being configured
   Vx::VxID myVortexId;              //!< Vortex ID of the configured field
};
 
 
//! \brief Templated class for storing and updating typed configuration values
//!
//! Extends the base configuration element with type-specific storage and update logic.
//! Specializations exist for certain types that require custom handling (e.g., DtVector).
template <typename T>
class VREVRFVORTEX_DLL DtVortexConfigurationElement : public DtVortexConfigurationBaseElement
{
public:
   //! \brief Constructor with field initialization
   //!
   //! Creates a typed configuration element associated with the specified Vortex field.
   //!
   //! \param field Pointer to the Vortex field to be configured
   explicit DtVortexConfigurationElement(VxData::FieldBase* field);
 
   //! \brief Virtual destructor
   //!
   //! Allows for proper cleanup of derived classes.
   virtual ~DtVortexConfigurationElement() override;
 
   //! \brief Updates the Vortex field with the stored value
   //!
   //! Implements the pure virtual function from the base class to
   //! set the value in the Vortex field.
   //!
   //! \return True if the update succeeded, false otherwise
   virtual bool updateConfigValue() override;
 
   //! \brief Gets the current configuration value
   //!
   //! \return The current value stored in this configuration element
   T value() { return myValue; }
 
   //! \brief Sets the configuration value
   //!
   //! \param val The value to store in this configuration element
   void setValue(const T& val);
 
protected:
   T myValue; //!< The typed value stored in this configuration element
};
 
 
//! \brief Type definitions for configuration entries
//!
//! ConfigurationEntry pairs a descriptor with its associated path strings.
//! ConfigurationEntryList is a collection of these entries.
using ConfigurationEntry = std::pair<DtVortexConfigurationElementDescriptor*, std::vector<std::string>>;
using ConfigurationEntryList = std::vector<ConfigurationEntry>;
 
//! \brief Main class for managing Vortex configuration parameters
//!
//! Handles parsing of configuration descriptors and updating of Vortex fields
//! with the specified values. Supports configuration via the VxVHLInterface.
class VREVRFVORTEX_DLL DtVortexConfiguration
{
public:
   //! \brief Constructor with interface and descriptor
   //!
   //! Initializes the configuration manager with the specified Vortex interface
   //! and configuration descriptor.
   //!
   //! \param iface Weak interface to the Vortex VHL interface
   //! \param desc Descriptor containing the configuration settings to apply
   DtVortexConfiguration(VxSim::VxWeakInterface<VxSim::VxVHLInterface> iface, DtVortexConfigurationDescriptor desc);
 
   //! \brief Destructor
   //!
   //! Cleans up resources used by the configuration manager.
   virtual ~DtVortexConfiguration();
 
   //! \brief Parses the configuration descriptor
   //!
   //! Iterates through the top-level entries in the descriptor and processes
   //! each one according to its type. For each entry, it locates the corresponding
   //! Vortex field and creates a configuration element to store the value.
   virtual void parseValues();
 
   //! \brief Updates all configuration values in Vortex
   //!
   //! Applies all stored configuration values to their corresponding
   //! Vortex fields. This method should be called after parseValues()
   //! to apply the configuration.
   virtual void updateVehicle();
 
protected:
   //! \brief Parses a configuration element using the Vortex interface
   //!
   //! Locates the specified parameter in Vortex via the VHL interface
   //! and creates a configuration element for it.
   //!
   //! \param elementDescriptor Descriptor for the element to parse
   virtual void parseUsingInterface(DtVortexConfigurationElementDescriptor* elementDescriptor);
 
   //! \brief Parses and adds a configuration element
   //!
   //! Creates a typed configuration element based on the descriptor's value
   //! type and adds it to the collection of elements.
   //!
   //! \param field Pointer to the Vortex field to configure
   //! \param elementDescriptor Descriptor containing the value to apply
   virtual void parseAndAddElement(VxData::FieldBase* field, DtVortexConfigurationElementDescriptor* elementDescriptor);
 
protected:
   VxSim::VxWeakInterface<VxSim::VxVHLInterface> myInterface; //!< Interface to the Vortex VHL system
 
   DtVortexConfigurationDescriptor myDescriptor;              //!< Descriptor containing configuration settings
   std::vector<std::shared_ptr<DtVortexConfigurationBaseElement>>
      myParameterElements;                                    //!< Collection of configured elements
};
} // namespace makVre