vortexConfigurationElementDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vortexConfigurationElementDescriptor.h
//! \brief Defines DtVortexConfigurationElementDescriptor for individual Vortex physics configuration parameters
//! \ingroup vreVrfVortexObjparam
 
#pragma once
 
#include "vreVrfVortexObjparam/export.h"
#include <vrfutil/rwTemplatedList.h>
 
#include <readerWriter/readerWriter.h>
#include <readerWriter/rwBoolean.h>
#include <readerWriter/rwReal.h>
#include <readerWriter/rwInt.h>
#include <readerWriter/rwVector.h>
#include <readerWriter/rwString.h>
 
namespace makVre
{
//! \brief Type identifier string for the DtVortexConfigurationElementDescriptor class
const char DtVortexConfigurationElementDescriptorType[] = "DtVortexConfigurationElementDescriptor";
 
//! \brief Descriptor for individual Vortex physics configuration parameters
//!
//! DtVortexConfigurationElementDescriptor represents a single parameter in the Vortex physics
//! configuration. It supports multiple data types (boolean, vector, integer, real, string, and filename)
//! and stores the parameter name along with its value. This class provides type-specific accessors
//! and modifiers and supports serialization to and from XML.
class VREVRFVORTEXOBJPARAM_DLL DtVortexConfigurationElementDescriptor : public DtReaderWriter
{
protected:
   //! \brief Protected default constructor
   //!
   //! Creates an empty configuration element descriptor
   DtVortexConfigurationElementDescriptor();
 
public:
   //! \brief Constructor with element name and registry
   //! \param name Name of the configuration element
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexConfigurationElementDescriptor(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Constructor with symbol element name and registry
   //! \param name Symbol string name of the configuration element
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexConfigurationElementDescriptor(const DtSymbolString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig Original configuration element descriptor to copy from
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexConfigurationElementDescriptor(
      const DtVortexConfigurationElementDescriptor& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Assignment operator
   //! \param orig Original configuration element descriptor to copy from
   //! \return Reference to this configuration element descriptor after assignment
   DtVortexConfigurationElementDescriptor& operator=(const DtVortexConfigurationElementDescriptor& orig);
 
   //! \brief Virtual destructor
   virtual ~DtVortexConfigurationElementDescriptor() override;
 
   //! \brief Sets the parameter name
   //! \param name The name to set for this parameter
   virtual void setParameterName(const DtString& name);
 
   //! \brief Gets the parameter name
   //! \return The name of this parameter
   virtual const DtString& getParameterName() const;
 
   //! \brief Checks if a parameter name has been specified
   //! \return True if the parameter name has been specified, false otherwise
   virtual bool parameterNameSpecified() const;
 
   //! \brief Gets the boolean value
   //! \return The boolean value of this parameter
   virtual bool getBooleanValue() const;
 
   //! \brief Sets the boolean value
   //! \param val The boolean value to set
   //! \param isSpecified Flag indicating if the value is specified
   virtual void setBooleanValue(bool val, bool isSpecified = true);
 
   //! \brief Checks if a boolean value has been specified
   //! \return True if a boolean value has been specified, false otherwise
   virtual bool booleanValueSpecified() const;
 
   //! \brief Gets the vector value
   //! \return The vector value of this parameter
   virtual DtVector getVectorValue() const;
 
   //! \brief Sets the vector value
   //! \param loc The vector value to set
   //! \param isSpecified Flag indicating if the value is specified
   virtual void setVectorValue(const DtVector& loc, bool isSpecified = true);
 
   //! \brief Checks if a vector value has been specified
   //! \return True if a vector value has been specified, false otherwise
   virtual bool vectorValueSpecified() const;
 
   //! \brief Gets the integer value
   //! \return The integer value of this parameter
   virtual int getIntValue() const;
 
   //! \brief Sets the integer value
   //! \param loc The integer value to set
   //! \param isSpecified Flag indicating if the value is specified
   virtual void setIntValue(const int loc, bool isSpecified = true);
 
   //! \brief Checks if an integer value has been specified
   //! \return True if an integer value has been specified, false otherwise
   virtual bool intValueSpecified() const;
 
   //! \brief Gets the real (double) value
   //! \return The real value of this parameter
   virtual double getRealValue() const;
 
   //! \brief Sets the real (double) value
   //! \param val The real value to set
   //! \param isSpecified Flag indicating if the value is specified
   virtual void setRealValue(double val, bool isSpecified = true);
 
   //! \brief Checks if a real value has been specified
   //! \return True if a real value has been specified, false otherwise
   virtual bool realValueSpecified() const;
 
   //! \brief Gets the string value
   //! \return The string value of this parameter
   virtual const DtString& getStringValue() const;
 
   //! \brief Sets the string value
   //! \param str The string value to set
   //! \param isSpecified Flag indicating if the value is specified
   virtual void setStringValue(const DtString& str, bool isSpecified = true);
 
   //! \brief Checks if a string value has been specified
   //! \return True if a string value has been specified, false otherwise
   virtual bool stringValueSpecified() const;
 
   //! \brief Gets the filename value
   //! \return The filename value of this parameter
   virtual const DtString& getFilenameValue() const;
 
   //! \brief Sets the filename value
   //! \param filename The filename value to set
   //! \param isSpecified Flag indicating if the value is specified
   virtual void setFilenameValue(const DtString& filename, bool isSpecified = true);
 
   //! \brief Checks if a filename value has been specified
   //! \return True if a filename value has been specified, false otherwise
   virtual bool filenameValueSpecified() const;
 
   //! \brief Gets the type identifier for reader/writer operations
   //! \return Type identifier string
   virtual const char* readerWriterType() const override;
 
   //! \brief Gets the XML type identifier for serialization
   //! \return XML type identifier string used when archiving to an XML stream
   static const char* theXmlType();
 
   //! \brief Gets the XML type identifier for this instance
   //! \return XML type identifier string
   virtual const char* xmlType() const override { return theXmlType(); }
 
protected:
   //! \brief The name of this parameter
   DtRwString myParameterName;
 
   //! \brief The boolean value of this parameter
   DtRwBoolean myBoolValue;
 
   //! \brief The vector value of this parameter
   DtRwVector myVectorValue;
 
   //! \brief The integer value of this parameter
   DtRwInt myIntValue;
 
   //! \brief The real (double) value of this parameter
   DtRwReal myRealValue;
 
   //! \brief The string value of this parameter
   DtRwString myStringValue;
 
   //! \brief The filename value of this parameter
   DtRwString myFilenameValue;
};
 
//! \brief Type definition for a list of Vortex configuration element descriptors
//!
//! This list template specialization manages ownership of the descriptors
//! and handles proper deletion when the list is destroyed
using DtVortexConfigurationElementList = DtRwTemplatedListPtr<DtVortexConfigurationElementDescriptor, true>;
} // namespace makVre