InversionOfControlAccessor.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "Application.h"
#include "ApplicationModule.h"
#include "Module.h"
#include "Utilities.h"
#include "VariableNetworkNode.h"
 
#include <boost/smart_ptr/shared_ptr.hpp>
 
#include <string>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  class InversionOfControlAccessor {
   public:
    virtual ~InversionOfControlAccessor();
 
    void setMetaData(const std::optional<std::string>& name, const std::optional<std::string>& unit = {},
        const std::optional<std::string>& description = {},
        const std::optional<std::unordered_set<std::string>>& tags = {});
 
    void addTag(const std::string& tag) { _node.addTag(tag); }
 
    void addTags(const std::unordered_set<std::string>& tags);
 
    const std::unordered_set<std::string>& getTags();
 
    explicit operator VariableNetworkNode() { return _node; }
    explicit operator VariableNetworkNode() const { return _node; }
 
    void replace(Derived&& other);
 
    [[nodiscard]] EntityOwner* getOwner() const { return _node.getOwningModule(); }
 
    [[nodiscard]] Model::ProcessVariableProxy getModel() const { return _node.getModel(); }
 
    template<typename UserType>
    [[nodiscard]] bool checkMetadataWriteDifference();
 
   protected:
    InversionOfControlAccessor(Module* owner, const std::string& name, VariableDirection direction, std::string unit,
        size_t nElements, UpdateMode mode, const std::string& description, const std::type_info* valueType,
        const std::unordered_set<std::string>& tags = {});
 
    InversionOfControlAccessor() = default;
 
    [[nodiscard]] std::string completeDescription(EntityOwner* owner, const std::string& description) const;
 
    void registerInModel();
 
    void init();
 
    void deinit();
 
    VariableNetworkNode _node;
 
   private:
    bool _initCalled{false};
    bool _deinitCalled{false};
  };
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<typename Derived>
  InversionOfControlAccessor<Derived>::~InversionOfControlAccessor() {
    if(_node.getType() == NodeType::Application) {
      assert(_initCalled);
      assert(_deinitCalled);
    }
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  void InversionOfControlAccessor<Derived>::setMetaData(const std::optional<std::string>& name,
      const std::optional<std::string>& unit, const std::optional<std::string>& description,
      const std::optional<std::unordered_set<std::string>>& tags) {
    std::optional<std::string> description_ = description;
    if(description.has_value()) {
      description_ = completeDescription(getOwner(), description.value());
    }
    _node.setMetaData(name, unit, description_, tags);
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  void InversionOfControlAccessor<Derived>::addTags(const std::unordered_set<std::string>& tags) {
    for(const auto& tag : tags) {
      _node.addTag(tag);
    }
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  const std::unordered_set<std::string>& InversionOfControlAccessor<Derived>::getTags() {
    return _node.getTags();
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  void InversionOfControlAccessor<Derived>::replace(Derived&& other) {
    if(static_cast<Derived*>(this)->_impl != nullptr || other._impl != nullptr) {
      try {
        throw ChimeraTK::logic_error(
            "Variable has been destroyed with active connections while application is still running");
      }
      catch(ChimeraTK::logic_error& ex) {
        std::terminate();
      }
    }
 
    // remove accessor from owning module
    if(getOwner() != nullptr) {
      getOwner()->unregisterAccessor(_node);
    }
 
    // remove node from model
    if(getModel().isValid()) {
      getModel().removeNode(_node);
    }
 
    // transfer the node
    _node = std::move(other._node);
    other._node = VariableNetworkNode(); // Make sure the destructor of other sees an invalid node
 
    // update the app accessor pointer in the node
    if(_node.getType() == NodeType::Application) {
      _node.setAppAccessorPointer(static_cast<Derived*>(this));
    }
    else {
      assert(_node.getType() == NodeType::invalid);
    }
    // Note: the accessor is registered by the VariableNetworkNode, so we don't have to re-register.
 
    _initCalled = other._initCalled;
    _deinitCalled = other._deinitCalled;
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  std::string InversionOfControlAccessor<Derived>::completeDescription(
      EntityOwner* owner, const std::string& description) const {
    auto ownerDescription = owner->getFullDescription();
    if(ownerDescription.empty()) {
      return description;
    }
    if(description.empty()) {
      return ownerDescription;
    }
    return ownerDescription + " - " + description;
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  InversionOfControlAccessor<Derived>::InversionOfControlAccessor(Module* owner, const std::string& name,
      VariableDirection direction, std::string unit, size_t nElements, UpdateMode mode, const std::string& description,
      const std::type_info* valueType, const std::unordered_set<std::string>& tags)
  : _node(owner, nullptr, ChimeraTK::Utilities::raiseIftrailingSlash(name, false), direction, unit, nElements, mode,
        completeDescription(owner, description), valueType, tags) {
    static_assert(std::is_base_of<InversionOfControlAccessor<Derived>, Derived>::value,
        "InversionOfControlAccessor<> must be used in a curiously recurring template pattern!");
 
    registerInModel();
 
    owner->registerAccessor(_node);
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  void InversionOfControlAccessor<Derived>::init() {
    _initCalled = true;
 
    /*
     * This initialises pointer to App accessor.  We cannot really do it in the constructor, since it then involves a
     * static_cast into the App Accessor type, which is undefined behaviour at that point in time (base class
     * constructor). This is found by ASAN.
     */
    _node.setAppAccessorPointer(static_cast<Derived*>(this));
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  void InversionOfControlAccessor<Derived>::deinit() {
    _deinitCalled = true;
 
    // This check and deregistration code involves "static_cast<Derived*>(this)" which is not allowed in the
    // destructor any more - the derived part of the object is already gone. In the destructor there is no reliable way
    // to get to the pointer to the implementation, since it is held by the other inheritance branch which may already
    // be gone.
    if(getOwner() != nullptr) {
      if(static_cast<Derived*>(this)->_impl != nullptr) {
        auto* entity = getOwner();
 
        if(entity != nullptr) {
          auto* owner = dynamic_cast<Module*>(entity);
          while(owner->getOwner() != nullptr) {
            owner = dynamic_cast<Module*>(owner->getOwner());
          }
 
          auto* application = dynamic_cast<Application*>(owner);
          assert(application != nullptr);
 
          if(application->getLifeCycleState() == LifeCycleState::run) {
            try {
              throw ChimeraTK::logic_error(
                  "Variable has been destroyed with active connections while application is "
                  "still running. Maybe the Application did not call shutdown() in its destructor?");
            }
            catch(ChimeraTK::logic_error&) {
              std::terminate();
            }
          }
        }
      }
      getOwner()->unregisterAccessor(_node);
    }
    if(getModel().isValid()) {
      try {
        getModel().removeNode(_node);
      }
      catch(ChimeraTK::logic_error& e) {
        std::cerr << "ChimeraTK::logic_error caught: " << e.what() << std::endl;
        std::terminate();
      }
    }
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  void InversionOfControlAccessor<Derived>::registerInModel() {
    _node.registerInModel();
  }
 
  /********************************************************************************************************************/
 
  template<typename Derived>
  template<typename UserType>
  bool InversionOfControlAccessor<Derived>::checkMetadataWriteDifference() {
    auto& ndra = dynamic_cast<NDRegisterAccessorAbstractor<UserType>&>(*this);
 
    // make sure to propagate initial values
    if(ndra.getVersionNumber() == VersionNumber(nullptr)) {
      return true;
    }
 
    // Need to get to the MetaDataPropagatingRegisterDecorator to obtain the last written data validity for this PV.
    // The dynamic_cast is ok, since the MetaDataPropagatingRegisterDecorator is always the outermost accessor, cf.
    // the data validity propagation specification, Section 2.5.1.
    const auto& targetMetaDataPropagatingDecorator =
        dynamic_cast<const MetaDataPropagatingRegisterDecorator<UserType>&>(*ndra.getImpl());
 
    // Special case: propagation from module to output explicitly suppressed by tag
    if(targetMetaDataPropagatingDecorator.getDisableDataValidityPropagation()) {
      return targetMetaDataPropagatingDecorator.getTargetValidity() != ndra.dataValidity();
    }
 
    // Special case: DataValidity has been overridden for this PV to faulty
    if(ndra.dataValidity() == DataValidity::faulty) {
      // Last written DataValidity != faulty -> write is necessary
      return targetMetaDataPropagatingDecorator.getTargetValidity() != DataValidity::faulty;
    }
 
    // Check with DataValidity from owning module
    return targetMetaDataPropagatingDecorator.getTargetValidity() != this->getOwner()->getDataValidity();
  }
 
  /********************************************************************************************************************/
 
} // namespace ChimeraTK