vreGlstudioUpdater.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreGlstudioUpdater.h
//! \brief Defines templates for GLStudio attribute updaters with simulation state awareness
//! \ingroup vrePilotFrontend
 
#pragma once
 
#include <vreMessageManager/vreMessageManager.h>
#include <vreMessages/simulationState.h>
 
#include <vrvGlStudioShared/DtGlStudioAttributeUpdater.h>
 
namespace makVre
{
//! \brief Template class that extends GLStudio updaters with simulation state awareness
//!
//! \tparam UpdaterBase Base updater class to extend
//!
//! This template extends GLStudio attribute updaters to be aware of simulation state,
//! allowing instruments to be disabled based on aircraft system states. It caches the
//! last valid value to avoid excessive updates and handles simulation state changes.
template <typename UpdaterBase>
class DtVreGlstudioUpdater : public UpdaterBase
{
public:
   //! \brief Default constructor
   DtVreGlstudioUpdater()
      : UpdaterBase()
      , myLastValue("")
      , myActive(false)
   {
   }
 
   //! \brief Virtual destructor
   //!
   //! Removes message handlers when the updater is destroyed
   virtual ~DtVreGlstudioUpdater()
   {
      DtVreMessageManager::instance().removeHandler(SimulationStateMessage::theType(),
         DtVreMessageDelegate(this, &DtVreGlstudioUpdater<UpdaterBase>::handleSimulationStateMessage));
   }
 
   //! \brief Initializes the updater
   //! \param smoother Pointer to the smoother to use for value smoothing
   //! \param de Pointer to the display element
   //!
   //! Registers message handlers and initializes the base updater
   virtual void init(DtSmoother* smoother, makVrv::DtDe* de)
   {
      DtVreMessageManager::instance().addHandler(SimulationStateMessage::theType(),
         DtVreMessageDelegate(this, &DtVreGlstudioUpdater<UpdaterBase>::handleSimulationStateMessage));
 
      UpdaterBase::init(smoother, de);
   }
 
   //! \brief Gets the current value as a string
   //! \param time Current simulation time in seconds
   //! \return Current value formatted as a string
   //!
   //! If the instrument is active, updates the cached value. Otherwise, returns the last cached value.
   virtual std::string value(double time)
   {
      if (myActive)
      {
         myLastValue = UpdaterBase::value(time);
      }
      return myLastValue;
   }
 
protected:
   //! \brief Handles simulation state change messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Updates the active state of the instrument based on the list of disabled instruments
   //! in the simulation state message.
   virtual DtVreMessageResult handleSimulationStateMessage(makVre::DtVreMessage* msg)
   {
      SimulationStateMessage* smsg = static_cast<SimulationStateMessage*>(msg);
      const std::vector<std::string>& instruments = smsg->getDisabledInstruments();
      myActive = std::find(instruments.begin(), instruments.end(), myStateAttribute) == instruments.end();
      return HANDLED;
   }
 
private:
   //! \brief Copy constructor (not implemented)
   //! \param other Source object to copy from
   DtVreGlstudioUpdater(const DtVreGlstudioUpdater& other);
 
   //! \brief Assignment operator (not implemented)
   //! \param other Source object to assign from
   //! \return Reference to this object
   DtVreGlstudioUpdater& operator=(const DtVreGlstudioUpdater& other);
 
public:
   //! \brief Name of the state attribute this updater is associated with
   std::string myStateAttribute;
 
   //! \brief Last calculated value, cached to avoid unnecessary updates
   std::string myLastValue;
 
   //! \brief Flag indicating if this instrument is currently active
   bool myActive;
};
 
//! \brief Creator template for registering VRE GLStudio updaters
//!
//! \tparam VreGlstudioUpdater Updater class to create
//! \tparam GlstudioUpdaterCreator Base creator class
//!
//! Factory template that creates instances of GLStudio updaters with simulation
//! state awareness. It allows replacing existing updaters or creating new ones.
//! \ingroup vrePilotFrontend
template <typename VreGlstudioUpdater, typename GlstudioUpdaterCreator>
class DtVreGlstudioUpdaterCreator : public GlstudioUpdaterCreator
{
public:
   //! \brief Constructor for replacing an existing updater
   //! \param stateAttribute Name of the state attribute to associate with
   //!
   //! Use this constructor to replace an existing updater with a VRE-aware version.
   DtVreGlstudioUpdaterCreator(const std::string& stateAttribute)
      : GlstudioUpdaterCreator()
      , myStateAttribute(stateAttribute)
   {
   }
 
   //! \brief Constructor for creating a new updater with a custom name
   //! \param stateAttribute Name of the state attribute to associate with
   //! \param name Custom name for the updater
   //!
   //! Use this constructor to install this updater with a new name,
   //! instead of replacing the base class updater.
   DtVreGlstudioUpdaterCreator(const std::string& stateAttribute, const std::string& name)
      : GlstudioUpdaterCreator()
      , myStateAttribute(stateAttribute)
   {
      this->myName = name;
   }
 
   //! \brief Virtual destructor
   virtual ~DtVreGlstudioUpdaterCreator() {};
 
   //! \brief Creates a new instance of the updater
   //! \return Pointer to a newly created updater
   //!
   //! Creates a new VRE GLStudio updater instance and configures its state attribute.
   virtual makVrv::DtGlStudioAttributeUpdater* create() const
   {
      VreGlstudioUpdater* updater = new VreGlstudioUpdater;
      updater->myStateAttribute = myStateAttribute;
      return updater;
   }
 
   std::string myStateAttribute;
 
private:
   DtVreGlstudioUpdaterCreator();
};
} // namespace makVre