Application.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 "CircularDependencyDetector.h"
#include "ConnectionMaker.h"
#include "Flags.h"
#include "InternalModule.h"
#include "Logger.h"
#include "Model.h"
#include "ModuleGroup.h"
#include "TestableMode.h"
 
#ifdef CHIMERATK_APPLICATION_CORE_WITH_PYTHON
#  include "PythonModuleManager.h"
#endif
 
#include <ChimeraTK/ControlSystemAdapter/ApplicationBase.h>
#include <ChimeraTK/DeviceBackend.h>
 
#include <atomic>
#include <mutex>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class Module;
  class VariableNetwork;
  class TestFacility;
  class DeviceManager;
  class ApplicationModule;
 
  template<typename UserType>
  class FanOut;
  template<typename UserType>
  class ConsumingFanOut;
 
  namespace detail {
    struct TestableMode;
  } // namespace detail
 
  /********************************************************************************************************************/
 
  class Application : public ApplicationBase, public ModuleGroup {
   public:
    explicit Application(const std::string& name);
 
    ~Application() override;
 
    using ApplicationBase::getName;
 
    void shutdown() override;
 
    void initialise() override;
 
    void optimiseUnmappedVariables(const std::set<std::string>& names) override;
 
    void run() override;
 
    Model::RootProxy getModel() { return _model; }
 
    void generateXML();
 
    void generateDOT();
 
    static Application& getInstance();
 
    static bool hasInstance() { return instance != nullptr; }
 
    void enableTestableMode();
 
    detail::TestableMode& getTestableMode() { return _testableMode; }
 
    static void registerThread(const std::string& name);
 
    ModuleType getModuleType() const override { return ModuleType::ModuleGroup; }
 
    std::string getQualifiedName() const override { return "/" + _name; }
 
    std::string getFullDescription() const override { return ""; }
 
    void enableVariableDebugging(const VariableNetworkNode& node) {
      _debugMode_variableList.insert(node.getUniqueId());
    }
 
    static void incrementDataLossCounter(const std::string& name);
 
    static size_t getAndResetDataLossCounter();
 
    boost::shared_ptr<DeviceManager> getDeviceManager(const std::string& aliasOrCDD);
 
    std::map<std::string, boost::shared_ptr<DeviceManager>> const& getDeviceManagerMap() { return _deviceManagerMap; }
 
    LifeCycleState getLifeCycleState() const { return _lifeCycleState; }
 
    VersionNumber getStartVersion() const { return _startVersion; }
    ApplicationModule* getVersionInfoProvider() { return _versionInfoProvider; }
    void setVersionInfoProvider(ApplicationModule* provider) { _versionInfoProvider = provider; }
 
    size_t getCircularNetworkInvalidityCounter(size_t circularNetworkHash) const {
      return _circularNetworkInvalidityCounters.at(circularNetworkHash);
    }
 
#ifdef CHIMERATK_APPLICATION_CORE_WITH_PYTHON
    PythonModuleManager& getPythonModuleManager() { return _pythonModuleManager; }
#endif
 
    ConfigReader& getConfigReader() { return *_defaultConfigReader; }
 
   protected:
    friend class Module;
    friend class VariableNetwork;
    friend class VariableNetworkNode;
    friend class VariableNetworkGraphDumpingVisitor;
    friend class VariableNetworkModuleGraphDumpingVisitor;
    friend class XMLGeneratorVisitor;
    friend struct StatusAggregator;
    friend struct detail::TestableMode;
    friend class NetworkVisitor;
    friend class ConnectionMaker;
 
    template<typename UserType>
    friend class ExceptionHandlingDecorator;
 
    Model::RootProxy _model;
 
    ConnectionMaker _cm{*this};
 
    std::list<boost::shared_ptr<InternalModule>> _internalModuleList;
 
    std::map<std::string, boost::shared_ptr<DeviceManager>> _deviceManagerMap;
 
    bool _testFacilityRunApplicationCalled{false};
 
    bool _initialiseCalled{false};
 
    bool _runCalled{false};
 
    std::map<size_t, size_t> _pvIdMap;
 
    detail::CircularDependencyDetector _circularDependencyDetector;
    detail::TestableMode _testableMode;
 
    std::unordered_set<const void*> _debugMode_variableList;
 
    std::atomic<size_t> _dataLossCounter{0};
 
    std::atomic<LifeCycleState> _lifeCycleState{LifeCycleState::initialisation};
 
    VersionNumber _startVersion;
 
    ApplicationModule* _versionInfoProvider{nullptr};
 
    std::map<size_t, std::atomic<uint64_t>> _circularNetworkInvalidityCounters;
 
    std::map<size_t, std::list<EntityOwner*>> _circularDependencyNetworks;
 
    std::shared_ptr<Logger> _logger{Logger::getSharedPtr()};
 
#ifdef CHIMERATK_APPLICATION_CORE_WITH_PYTHON
    PythonModuleManager _pythonModuleManager;
#endif
 
    std::shared_ptr<ConfigReader> _configReader;
    ConfigReader* _defaultConfigReader{nullptr};
 
    friend class TestFacility; // needs access to testableMode variables
 
    template<typename UserType>
    friend class DebugPrintAccessorDecorator; // needs access to the idMap
    template<typename UserType>
    friend class MetaDataPropagatingRegisterDecorator; // needs to access circularNetworkInvalidityCounters
    friend class ApplicationModule;                    // needs to access circularNetworkInvalidityCounters
    friend struct detail::CircularDependencyDetector;
    friend class ConfigReader; // needs access to _configReader to replace it eventually
 
    VersionNumber getCurrentVersionNumber() const override {
      throw ChimeraTK::logic_error("getCurrentVersionNumber() called on the application. This is probably "
                                   "caused by incorrect ownership of variables/accessors or VariableGroups.");
    }
    void setCurrentVersionNumber(VersionNumber) override {
      throw ChimeraTK::logic_error("setCurrentVersionNumber() called on the application. This is probably "
                                   "caused by incorrect ownership of variables/accessors or VariableGroups.");
    }
    DataValidity getDataValidity() const override {
      throw ChimeraTK::logic_error("getDataValidity() called on the application. This is probably "
                                   "caused by incorrect ownership of variables/accessors or VariableGroups.");
    }
    void incrementDataFaultCounter() override {
      throw ChimeraTK::logic_error("incrementDataFaultCounter() called on the application. This is probably "
                                   "caused by incorrect ownership of variables/accessors or VariableGroups.");
    }
    void decrementDataFaultCounter() override {
      throw ChimeraTK::logic_error("decrementDataFaultCounter() called on the application. This is probably "
                                   "caused by incorrect ownership of variables/accessors or VariableGroups.");
    }
    std::list<EntityOwner*> getInputModulesRecursively([[maybe_unused]] std::list<EntityOwner*> startList) override {
      throw ChimeraTK::logic_error("getInputModulesRecursively() called on the application. This is probably "
                                   "caused by incorrect ownership of variables/accessors or VariableGroups.");
    }
    size_t getCircularNetworkHash() const override {
      throw ChimeraTK::logic_error("getCircularNetworkHash() called on the application. This is probably "
                                   "caused by incorrect ownership of variables/accessors or VariableGroups.");
    }
  };
 
} /* namespace ChimeraTK */