VariableNetworkNode.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 "ConstantAccessor.h"
#include "Flags.h"
#include "Logger.h"
#include "MetaDataPropagatingRegisterDecorator.h"
#include "Model.h"
#include "Visitor.h"
 
#include <ChimeraTK/NDRegisterAccessorAbstractor.h>
 
#include <boost/shared_ptr.hpp>
 
#include <cassert>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class AccessorBase;
  class EntityOwner;
  struct VariableNetworkNode_data;
 
  /********************************************************************************************************************/
 
  class AnyType {};
 
  /********************************************************************************************************************/
 
  class VariableNetworkNode {
   public:
    VariableNetworkNode(const VariableNetworkNode& other);
 
    VariableNetworkNode& operator=(const VariableNetworkNode& rightHandSide);
 
    VariableNetworkNode(EntityOwner* owner, ChimeraTK::TransferElementAbstractor* accessorBridge,
        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 = {});
 
    VariableNetworkNode(const std::string& name, const std::string& devAlias, const std::string& regName,
        UpdateMode mode, VariableDirection direction, bool isReadable, const std::type_info& valTyp = typeid(AnyType),
        size_t nElements = 0);
 
    VariableNetworkNode(const std::string& pubName, VariableDirection direction,
        const std::type_info& valTyp = typeid(AnyType), size_t nElements = 0);
 
    VariableNetworkNode(const std::type_info* valTyp, bool makeFeeder, size_t length);
 
    VariableNetworkNode(const std::string& deviceAliasOrCdd, int);
 
    explicit VariableNetworkNode(boost::shared_ptr<VariableNetworkNode_data> pdata);
 
    VariableNetworkNode();
 
    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 clearOwner();
 
    void setValueType(const std::type_info& newType) const;
 
    void setDirection(VariableDirection newDirection) const;
 
    [[nodiscard]] bool hasImplementation() const;
 
    bool operator==(const VariableNetworkNode& other) const;
    bool operator!=(const VariableNetworkNode& other) const;
    bool operator<(const VariableNetworkNode& other) const;
 
    void dump(std::ostream& stream = std::cout) const;
 
    void addTag(const std::string& tag) const;
 
    [[nodiscard]] bool isCircularInput() const;
 
    [[nodiscard]] std::list<EntityOwner*> scanForCircularDepencency() const;
 
    [[nodiscard]] size_t getCircularNetworkHash() const;
 
    [[nodiscard]] bool isValid() const { return pdata && getType() != NodeType::invalid; }
 
    [[nodiscard]] NodeType getType() const;
    [[nodiscard]] UpdateMode getMode() const;
    [[nodiscard]] VariableDirection getDirection() const;
    [[nodiscard]] const std::type_info& getValueType() const;
    [[nodiscard]] std::string getName() const;
    [[nodiscard]] std::string getQualifiedName() const;
    [[nodiscard]] const std::string& getUnit() const;
    [[nodiscard]] const std::string& getDescription() const;
    [[nodiscard]] VariableNetworkNode getNodeToTrigger() const;
    [[nodiscard]] const std::string& getPublicName() const;
    [[nodiscard]] const std::string& getDeviceAlias() const;
    [[nodiscard]] const std::string& getRegisterName() const;
    [[nodiscard]] const std::unordered_set<std::string>& getTags() const;
    void setNumberOfElements(size_t nElements) const;
    [[nodiscard]] size_t getNumberOfElements() const;
    [[nodiscard]] ChimeraTK::TransferElementAbstractor& getAppAccessorNoType() const;
    [[nodiscard]] bool isReadable() const;
 
    [[nodiscard]] Model::ProcessVariableProxy getModel() const;
 
    void setModel(const Model::ProcessVariableProxy& model) const;
 
    void setPublicName(const std::string& name) const;
 
    template<typename UserType>
    ChimeraTK::NDRegisterAccessorAbstractor<UserType>& getAppAccessor() const;
 
    template<typename UserType>
    void setAppAccessorImplementation(boost::shared_ptr<ChimeraTK::NDRegisterAccessor<UserType>> impl) const;
 
    void setAppAccessorConstImplementation(const VariableNetworkNode& feeder) const;
 
    [[nodiscard]] const void* getUniqueId() const { return pdata.get(); }
 
    void setAppAccessorPointer(ChimeraTK::TransferElementAbstractor* accessor) const;
 
    [[nodiscard]] EntityOwner* getOwningModule() const;
 
    void setOwningModule(EntityOwner* newOwner) const;
 
    void accept(Visitor<VariableNetworkNode>& visitor) const;
 
    template<typename UserType>
    void setConstantValue(UserType value);
 
    template<typename UserType>
    UserType getConstantValue() const;
 
    void registerInModel();
 
    // protected:  @todo make protected again (with proper interface extension)
 
    boost::shared_ptr<VariableNetworkNode_data> pdata;
  };
 
  /********************************************************************************************************************/
 
  constexpr auto explicitDataValidityTag = "_ChimeraTK_NodeHasExplicitDataValidity";
 
  constexpr auto independentVersionTag = "_ChimeraTK_NodeHasIndependentVersion";
 
  /********************************************************************************************************************/
 
  struct VariableNetworkNode_data {
    VariableNetworkNode_data() = default;
 
    NodeType type{NodeType::invalid};
 
    UpdateMode mode{UpdateMode::invalid};
 
    VariableDirection direction{VariableDirection::invalid, false};
 
    const std::type_info* valueType{&typeid(AnyType)};
 
    std::string unit{ChimeraTK::TransferElement::unitNotSet};
 
    std::string description;
 
    ChimeraTK::TransferElementAbstractor* appNode{nullptr};
 
    VariableNetworkNode nodeToTrigger{nullptr};
 
    VariableNetworkNode externalTrigger{nullptr};
 
    std::string publicName;
 
    std::string name;
    std::string qualifiedName;
 
    std::string deviceAlias;
    std::string registerName;
    bool isReadable{true};
 
    size_t nElements{0};
 
    std::unordered_set<std::string> tags;
 
    std::map<VariableNetworkNode, VariableNetworkNode> nodeWithTrigger;
 
    EntityOwner* owningModule{nullptr};
 
    size_t circularNetworkHash{0};
 
    Model::NonOwningProxy<Model::ProcessVariableProxy> model;
 
    userTypeMap constantValue;
  };
 
  /********************************************************************************************************************/
  /*** Implementations ************************************************************************************************/
  /********************************************************************************************************************/
 
  template<typename UserType>
  ChimeraTK::NDRegisterAccessorAbstractor<UserType>& VariableNetworkNode::getAppAccessor() const {
    assert(typeid(UserType) == getValueType());
    assert(pdata->type == NodeType::Application);
    auto accessor = static_cast<ChimeraTK::NDRegisterAccessorAbstractor<UserType>*>(pdata->appNode);
    assert(accessor != nullptr);
    return *accessor;
  }
 
  /********************************************************************************************************************/
 
  template<typename UserType>
  void VariableNetworkNode::setAppAccessorImplementation(boost::shared_ptr<NDRegisterAccessor<UserType>> impl) const {
    auto decorated =
        boost::make_shared<MetaDataPropagatingRegisterDecorator<UserType>>(impl, getOwningModule(), getDirection());
    if(pdata->tags.find(explicitDataValidityTag) != pdata->tags.end()) {
      decorated->disableDataValidityPropagation();
    }
    if(pdata->tags.find(independentVersionTag) != pdata->tags.end()) {
      decorated->disableVersionNumberPropagation();
    }
 
    getAppAccessor<UserType>().replace(decorated);
    auto flagProvider = boost::dynamic_pointer_cast<MetaDataPropagationFlagProvider>(decorated);
    assert(flagProvider);
  }
 
  /********************************************************************************************************************/
 
  template<typename UserType>
  void VariableNetworkNode::setConstantValue(UserType value) {
    assert(pdata->type == NodeType::Constant);
    boost::fusion::at_key<UserType>(pdata->constantValue) = value;
  }
 
  /********************************************************************************************************************/
 
  template<typename UserType>
  UserType VariableNetworkNode::getConstantValue() const {
    assert(pdata->type == NodeType::Constant);
    return boost::fusion::at_key<UserType>(pdata->constantValue);
  }
 
  /********************************************************************************************************************/
 
} /* namespace ChimeraTK */