attributeProviderComponent.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file attributeProviderComponent.h
//! \ingroup vreVrfmodel
//! \brief Component for providing system attributes to simulation objects
//!
//! This file defines the DtAttributeProviderComponent class which provides a lightweight
//! mechanism to add system attributes to simulation objects through component configuration.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
#include <vrfobjcore/simComponent.h>
 
namespace makVre
{
const char DtAttributeProviderComponentType[] = "attribute-provider-component";
 
//! \brief Component for providing system attributes in a lightweight manner
//!
//! The DtAttributeProviderComponent exists to provide system attributes in a lightweight component.
//! This class does all its work in the init() function, so it should be configured with
//! is-enabled False, so its tick function is never called.
//! See vrfobjcore/componentSystem.h for information on system attributes.
class VREVRFMODEL_DLL DtAttributeProviderComponent : public DtSimComponent
{
public:
   //! \brief Helper class used for registering the attribute
   //!
   //! In init(), creates one for each attribute key value pair in the descriptor.
   class DtAttributeProvider
   {
   public:
      //! \brief Static provider function used in attribute registration
      //! \param usr Pointer to the DtAttributeProvider instance
      //! \return Reader/writer object for the attribute value
      static DtReaderWriter* provide(void* usr) { return ((DtAttributeProvider*)usr)->value(); }
 
      //! \brief Creates a reader/writer object for the attribute value
      //! \return New DtRwString containing the attribute value
      virtual DtReaderWriter* value() { return new DtRwString(myValue); }
 
      //! \brief The attribute key
      DtRwString myKey;
 
      //! \brief The attribute value
      DtRwString myValue;
   };
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtAttributeProviderComponent();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtAttributeProviderComponent(const DtAttributeProviderComponent& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent
   //! assignment.
   const DtAttributeProviderComponent& operator=(const DtAttributeProviderComponent& orig);
 
public:
   //! \brief Constructor
   //! \param name The name of this component
   //! \param owner The local object that owns this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new attribute provider component with the specified parameters.
   DtAttributeProviderComponent(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the attribute provider component.
   virtual ~DtAttributeProviderComponent() override;
 
   //! \brief Initializes the component
   //! \return True if initialization is successful, false otherwise
   //!
   //! Gets attributes to add from descriptor and installs a new
   //! DtAttributeProvider for each one.
   virtual bool init() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtAttributeProviderComponentType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc, DtReaderWriterRegistry* parentRegistry);
 
protected:
   //! \brief Collection of attribute providers
   //!
   //! A provider is created for each key-value pair in the descriptor.
   //! These are registered with the system via addAttributeProviderFunction.
   std::vector<DtAttributeProvider*> myProviders;
};
} // namespace makVre