EntityOwner.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 "Flags.h"
#include "Utilities.h"
#include "VariableNetworkNode.h"
#include <unordered_set>
 
#include <iostream>
#include <list>
#include <string>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class AccessorBase;
  class Module;
 
  /********************************************************************************************************************/
 
  using TAGS = const std::unordered_set<std::string>;
 
  std::string negateTag(const std::string& tag);
 
  /********************************************************************************************************************/
 
  class EntityOwner {
   public:
    EntityOwner(std::string name, std::string description, std::unordered_set<std::string> tags = {});
 
    EntityOwner();
 
    virtual ~EntityOwner() = default;
 
    EntityOwner(EntityOwner&& other) noexcept { operator=(std::move(other)); }
    EntityOwner(const EntityOwner& other) = delete;
 
    EntityOwner& operator=(EntityOwner&& other) noexcept;
    EntityOwner& operator=(const EntityOwner& other) = delete;
 
    const std::string& getName() const { return _name; }
 
    virtual std::string getQualifiedName() const = 0;
 
    std::string getQualifiedNameWithType() const;
 
    const std::string& getDescription() const { return _description; }
 
    virtual std::string getFullDescription() const = 0;
 
    std::list<VariableNetworkNode> getAccessorList() const { return _accessorList; }
 
    std::list<Module*> getSubmoduleList() const { return _moduleList; }
 
    std::list<VariableNetworkNode> getAccessorListRecursive() const;
 
    std::list<Module*> getSubmoduleListRecursive() const;
 
    void registerAccessor(VariableNetworkNode accessor);
 
    void unregisterAccessor(const VariableNetworkNode& accessor) { _accessorList.remove(accessor); }
 
    void registerModule(Module* module, bool addTags = true);
 
    virtual void unregisterModule(Module* module);
 
    void addTag(const std::string& tag);
 
    void dump(const std::string& prefix = "", std::ostream& stream = std::cout) const;
 
    enum class ModuleType { ApplicationModule, ModuleGroup, VariableGroup, ControlSystem, Device, Invalid };
 
    virtual ModuleType getModuleType() const = 0;
 
    virtual VersionNumber getCurrentVersionNumber() const = 0;
 
    virtual void setCurrentVersionNumber(VersionNumber versionNumber) = 0;
 
    virtual DataValidity getDataValidity() const = 0;
 
    virtual void incrementDataFaultCounter() = 0;
 
    virtual void decrementDataFaultCounter() = 0;
 
    virtual std::list<EntityOwner*> getInputModulesRecursively(std::list<EntityOwner*> startList) = 0;
 
    virtual size_t getCircularNetworkHash() const = 0;
 
    bool hasReachedTestableMode();
 
    template<typename T>
    std::string constant(T value);
 
    static constexpr std::string_view namePrefixConstant{"/@CONST@"};
 
   protected:
    std::string _name;
 
    std::string _description;
 
    std::list<VariableNetworkNode> _accessorList;
 
    std::list<Module*> _moduleList;
 
    std::unordered_set<std::string> _tags;
 
    std::atomic<bool> _testableModeReached{false};
  };
 
  /********************************************************************************************************************/
 
  template<typename T>
  std::string EntityOwner::constant(T value) {
    // Make sure every constant has its unique name to avoid differently typed inputs to be connected to the same
    // constant. Note that the template type argument T may not match the expected type by the application, since the
    // type of the constant is determined by the input accessor, not by the type of the value argument of this function.
    // We hence need to use both the type name and a unique counter as part of the name. The unique counter lives inside
    // this template function and hence counts for each type T separately!
    static std::atomic<uint64_t> uid(0);
    return std::string(namePrefixConstant) + "/" + DataType(typeid(T)).getAsString() + "/" + std::to_string(uid++) +
        "/" + Utilities::escapeName(userTypeToUserType<std::string>(value), false);
  }
 
  /********************************************************************************************************************/
 
} /* namespace ChimeraTK */