vortexInterfaceElementDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vortexInterfaceElementDescriptor.h
//! \brief Defines DtVortexInterfaceElementDescriptor for Vortex interface parameter elements
//! \ingroup vreVrfVortexObjparam
 
#pragma once
 
#include "vreVrfVortexObjparam/export.h"
#include <vrfutil/rwTemplatedList.h>
#include <readerWriter/rwString.h>
namespace makVre
{
//! \brief Type identifier string for the DtVortexInterfaceElementDescriptor class
const char DtVortexInterfaceElementDescriptorType[] = "DtVortexInterfaceElementDescriptor";
 
//! \brief Descriptor for individual Vortex interface parameter elements
//!
//! DtVortexInterfaceElementDescriptor represents a single parameter element within a Vortex
//! interface descriptor. It stores the name of the parameter in the Vortex physics engine
//! and its data type. These elements are used in input and output parameter lists to define
//! the interface for communication with the Vortex physics engine.
class VREVRFVORTEXOBJPARAM_DLL DtVortexInterfaceElementDescriptor : public DtReaderWriter
{
public:
   //! \brief Default constructor
   //!
   //! Creates an empty interface element descriptor
   DtVortexInterfaceElementDescriptor();
 
   //! \brief Constructor with element name and registry
   //! \param name Name of the interface element descriptor
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexInterfaceElementDescriptor(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Constructor with symbol element name and registry
   //! \param name Symbol string name of the interface element descriptor
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexInterfaceElementDescriptor(const DtSymbolString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig Original interface element descriptor to copy from
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexInterfaceElementDescriptor(
      const DtVortexInterfaceElementDescriptor& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Assignment operator
   //! \param orig Original interface element descriptor to copy from
   //! \return Reference to this interface element descriptor after assignment
   DtVortexInterfaceElementDescriptor& operator=(const DtVortexInterfaceElementDescriptor& orig);
 
   //! \brief Virtual destructor
   virtual ~DtVortexInterfaceElementDescriptor() override;
 
   //! \brief Sets the Vortex parameter name
   //! \param name The parameter name to set in the Vortex physics engine
   virtual void setVortexName(const DtString& name);
 
   //! \brief Gets the Vortex parameter name
   //! \return The parameter name in the Vortex physics engine
   virtual const DtString& vortexName() const;
 
   //! \brief Sets the data type of the parameter
   //! \param type The data type to set for this parameter
   virtual void setDataType(const DtString& type);
 
   //! \brief Gets the data type of the parameter
   //! \return The data type of this parameter
   virtual const DtString& dataType() 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 parameter name in the Vortex physics engine
   DtRwString myVortexName;
 
   //! \brief The data type of this parameter
   DtRwString myDataType;
};
 
//! \brief Type definition for a list of Vortex interface element descriptors
//!
//! This list template specialization manages ownership of the descriptors
//! and handles proper deletion when the list is destroyed
using DtVortexInterfaceElementList = DtRwTemplatedListPtr<DtVortexInterfaceElementDescriptor, true>;
} // namespace makVre