vreScriptReactiveTaskControllerDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreScriptReactiveTaskControllerDescriptor.h
//! \ingroup vreVrfobjparam
//! \brief Script reactive task controller descriptor for VREngage
//!
//! This file defines the DtVreScriptReactiveTaskControllerDescriptor class, which configures
//! script reactive task controller components in VREngage. It maintains a mapping between
//! roles and allowed reactive task script lists, controlling which scripts can be executed
//! based on entity roles.
 
#pragma once
 
#include "vreVrfobjparam/export.h"
 
#include <vrfutil/rwNLengthStringVector.h>
#include <vrfutil/rwTemplatedMap.h>
#include <readerWriter/rwString.h>
#include <vrfobjparam/componentDescriptor.h>
 
namespace makVre
{
//! \brief Type identifier string for the script reactive task controller descriptor
const char DtVreScriptReactiveTaskControllerDescriptorType[] = "vre-script-reactive-task-controller-descriptor";
 
//! \brief Type definition for a read/write map of roles to script lists
using DtRwRoleToScriptListMap = DtRwTemplatedMapPtr<DtRwString, DtRwNLengthStringVector>;
 
//! \brief Type definition for a standard map of roles to script lists
using DtRoleToScriptListMap = std::map<DtRwString, DtRwNLengthStringVector>;
 
//! \brief Script reactive task controller descriptor for VREngage
//!
//! This class defines a descriptor for script reactive task controller components in VREngage.
//! It maintains a mapping between roles and allowed reactive task script lists, controlling
//! which scripts can be executed based on entity roles. This allows for role-specific behavior
//! scripts to be assigned to entities during engagement scenarios.
class VREVRFOBJPARAM_DLL DtVreScriptReactiveTaskControllerDescriptor : public DtComponentDescriptor
{
public:
   //! \brief Default constructor (deleted)
   //!
   //! Default constructor is explicitly deleted to prevent
   //! creation of instances without proper initialization.
   DtVreScriptReactiveTaskControllerDescriptor() = delete;
 
   //! \brief Constructor with component name
   //! \param name The name of this component
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new script reactive task controller descriptor with the specified name.
   DtVreScriptReactiveTaskControllerDescriptor(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Constructor with component name as symbol string
   //! \param name The name of this component as a symbol string
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new script reactive task controller descriptor with the specified name.
   DtVreScriptReactiveTaskControllerDescriptor(const DtSymbolString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig The source descriptor to copy from
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new script reactive task controller descriptor as a copy of the provided original.
   DtVreScriptReactiveTaskControllerDescriptor(
      const DtVreScriptReactiveTaskControllerDescriptor& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Assignment operator
   //! \param orig The source descriptor to copy from
   //! \return Reference to this descriptor after assignment
   //!
   //! Assigns the contents of the provided descriptor to this one.
   DtVreScriptReactiveTaskControllerDescriptor& operator=(const DtVreScriptReactiveTaskControllerDescriptor& orig);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the descriptor.
   virtual ~DtVreScriptReactiveTaskControllerDescriptor() override;
 
   //! \brief Sets the role to script list mapping
   //! \param map The mapping of roles to allowed script lists
   //!
   //! Sets the mapping between roles and lists of scripts that are allowed to be executed
   //! by entities with those roles while they are engaged in tasks.
   virtual void setRoleToScriptListMap(const DtRoleToScriptListMap& map);
 
   //! \brief Gets the role to script list mapping
   //! \return Reference to the mapping of roles to allowed script lists
   //!
   //! Returns the mapping between roles and lists of scripts that are allowed to be executed
   //! by entities with those roles while they are engaged in tasks.
   virtual const DtRoleToScriptListMap& roleToScriptListMap() const;
 
   //! \brief Gets the reader/writer type identifier
   //! \return String identifying the reader/writer type
   //!
   //! Returns the type string used for reader/writer registration and lookup.
   //! Overrides the base class implementation.
   virtual const char* readerWriterType() const override;
 
   //! \brief Gets the XML type string used when archiving to an XML stream
   //! \return String identifying the XML type
   //!
   //! Returns the type string used when archiving this descriptor to an XML stream.
   static const char* theXmlType();
 
   //! \brief Gets the XML type for this instance
   //! \return String identifying the XML type
   //!
   //! Returns the type string used when archiving this descriptor to an XML stream.
   //! Overrides the base class implementation.
   virtual const char* xmlType() const override { return theXmlType(); }
 
   //! \brief Factory function to create a new instance of this descriptor
   //! \return Pointer to a newly created descriptor
   //!
   //! Static factory function used by the descriptor creation system to instantiate
   //! new instances of this descriptor type.
   static DtComponentDescriptor* creator();
 
protected:
   //! \brief Mapping of roles to allowed reactive task scripts
   //!
   //! Stores the mapping between roles and lists of scripts that are allowed to be executed
   //! by entities with those roles while they are engaged in tasks. This controls which
   //! reactive behavior scripts can run based on entity role assignments.
   DtRwRoleToScriptListMap myAllowedReactiveTasksWhileEngaged;
};
 
} // namespace makVre