vortexInterfaceDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vortexInterfaceDescriptor.h
//! \brief Defines DtVortexInterfaceDescriptor for managing Vortex interface parameters
//! \ingroup vreVrfVortexObjparam
 
#pragma once
 
#include "vreVrfVortexObjparam/export.h"
#include "vreVrfVortexObjparam/vortexInterfaceElementDescriptor.h"
 
namespace makVre
{
//! \brief Type identifier string for the DtVortexInterfaceDescriptor class
const char DtVortexInterfaceDescriptorType[] = "DtVortexInterfaceDescriptor";
 
//! \brief Descriptor for Vortex physics engine interfaces
//!
//! DtVortexInterfaceDescriptor manages interfaces for the Vortex physics engine,
//! defining input and output parameters through separate element lists. It provides
//! methods to set and retrieve the interface name and parameter lists, and supports
//! serialization to and from XML.
class VREVRFVORTEXOBJPARAM_DLL DtVortexInterfaceDescriptor : public DtReaderWriter
{
public:
   //! \brief Default constructor
   //!
   //! Creates an empty interface descriptor
   DtVortexInterfaceDescriptor();
 
   //! \brief Constructor with interface name and registry
   //! \param name Name of the interface descriptor
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexInterfaceDescriptor(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Constructor with symbol interface name and registry
   //! \param name Symbol string name of the interface descriptor
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexInterfaceDescriptor(const DtSymbolString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig Original interface descriptor to copy from
   //! \param parentRegistry Optional parent registry for reader/writer operations
   DtVortexInterfaceDescriptor(const DtVortexInterfaceDescriptor& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Assignment operator
   //! \param orig Original interface descriptor to copy from
   //! \return Reference to this interface descriptor after assignment
   DtVortexInterfaceDescriptor& operator=(const DtVortexInterfaceDescriptor& orig);
 
   //! \brief Virtual destructor
   virtual ~DtVortexInterfaceDescriptor() override;
 
   //! \brief Sets the name of the Vortex interface
   //! \param interfaceName The name to set for this interface
   virtual void setVortexInterfaceName(const std::string& interfaceName);
 
   //! \brief Gets the name of the Vortex interface
   //! \return The name of this interface
   virtual std::string vortexInterfaceName() const;
 
   //! \brief Sets the list of input interface elements
   //! \param list The list of input interface elements to set
   virtual void setInputList(const DtVortexInterfaceElementList& list);
 
   //! \brief Gets the list of input interface elements
   //! \return Constant reference to the list of input interface elements
   virtual const DtVortexInterfaceElementList& inputList() const;
 
   //! \brief Sets the list of output interface elements
   //! \param list The list of output interface elements to set
   virtual void setOutputList(const DtVortexInterfaceElementList& list);
 
   //! \brief Gets the list of output interface elements
   //! \return Constant reference to the list of output interface elements
   virtual const DtVortexInterfaceElementList& outputList() 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 Vortex interface
   DtRwString myInterfaceName;
 
   //! \brief List of input interface elements for this interface
   DtVortexInterfaceElementList myInputList;
 
   //! \brief List of output interface elements for this interface
   DtVortexInterfaceElementList myOutputList;
};
 
//! \brief Type definition for a list of Vortex interface descriptors
//!
//! This list template specialization manages ownership of the descriptors
//! and handles proper deletion when the list is destroyed
using DtVortexInterfaceDescriptorList = DtRwTemplatedListPtr<DtVortexInterfaceDescriptor, true>;
} // namespace makVre